@c -*-texinfo-*-
@c This is part of the GNU Guile Reference Manual.
-@c Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2006, 2010
+@c Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2006, 2010, 2011
@c Free Software Foundation, Inc.
@c See the file guile.texi for copying conditions.
@chapter Introduction
Guile is an implementation of the Scheme programming language. Scheme
-(@url{schemers.org}) is an elegant and conceptually simple dialect of
-Lisp, originated by Guy Steele and Gerald Sussman, and since evolved
-by the series of reports known as RnRS (the
+(@url{http://schemers.org/}) is an elegant and conceptually simple
+dialect of Lisp, originated by Guy Steele and Gerald Sussman, and since
+evolved by the series of reports known as RnRS (the
@tex
Revised$^n$
@end tex
@end ifnottex
Reports on Scheme).
-Unlike -- for example -- Python or Perl, Scheme has no benevolent
+Unlike, for example, Python or Perl, Scheme has no benevolent
dictator. There are many Scheme implementations, with different
characteristics and with communities and academic activities around
them, and the language develops as a result of the interplay between
* Interactive Programming::
* Supporting Multiple Languages::
* Obtaining and Installing Guile::
+* Organisation of this Manual::
* Typographical Conventions::
@end menu
The Scheme community has recently agreed and published R6RS, the
latest installment in the RnRS series. R6RS significantly expands the
core Scheme language, and standardises many non-core functions that
-implementations -- including Guile -- have previously done in
+implementations---including Guile---have previously done in
different ways. Guile has been updated to incorporate some of the
features of R6RS, and to adjust some existing features to conform to
the R6RS specification, but it is by no means a complete R6RS
-implementation.
+implementation. @xref{R6RS Support}.
Between R5RS and R6RS, the SRFI process (@url{http://srfi.schemers.org/})
standardised interfaces for many practical needs, such as multithreaded
@node Combining with C
@section Combining with C Code
-Like a shell, Guile can run interactively --- reading expressions from the user,
-evaluating them, and displaying the results --- or as a script interpreter,
+Like a shell, Guile can run interactively---reading expressions from the user,
+evaluating them, and displaying the results---or as a script interpreter,
reading and executing Scheme code from a file. Guile also provides an object
library, @dfn{libguile}, that allows other applications to easily incorporate a
complete Scheme interpreter. An application can then use Guile as an extension
and history. First is that Guile has always been targeted as an
extension language. Hence its C API has always been of great
importance, and has been developed accordingly. Second and third are
-rather technical points -- that Guile uses conservative garbage
+rather technical points---that Guile uses conservative garbage
collection, and that it implements the Scheme concept of continuations
-by copying and reinstating the C stack -- but whose practical
+by copying and reinstating the C stack---but whose practical
consequence is that most existing C code can be glued into Guile as
is, without needing modifications to cope with strange Scheme
execution flows. Last is the module system, which helps extensions to
within the Emacs environment, the idea was that Guile should do the
same for other GNU Project applications. This remains true today.
+The idea of extensibility is closely related to the GNU project's
+primary goal, that of promoting software freedom. Software freedom
+means that people receiving a software package can modify or enhance
+it to their own desires, including in ways that may not have occurred
+at all to the software's original developers. For programs written in
+a compiled language like C, this freedom covers modifying and
+rebuilding the C code; but if the program also provides an extension
+language, that is usually a much friendlier and lower-barrier-of-entry
+way for the user to start making their own changes.
+
Guile is now used by GNU project applications such as AutoGen, Lilypond, Denemo,
Mailutils, TeXmacs and Gnucash, and we hope that there will be many more in
future.
quickly with code changes, the system should allow parts of the source code to
be modified and reloaded into the running program, to take immediate effect.
-Guile allows this kind of interactive programming, and this distinguishes it
-from many Scheme implementations that instead prioritise running a fixed Scheme
-program as fast as possible --- because there are tradeoffs between performance
-and the ability to modify parts of an already running program. There are faster
-Schemes than Guile, but Guile is a GNU project and so prioritises the GNU vision
-of programming freedom and experimentation.
+Guile is designed for this kind of interactive programming, and this
+distinguishes it from many Scheme implementations that instead prioritise
+running a fixed Scheme program as fast as possible---because there are
+tradeoffs between performance and the ability to modify parts of an already
+running program. There are faster Schemes than Guile, but Guile is a GNU
+project and so prioritises the GNU vision of programming freedom and
+experimentation.
@node Supporting Multiple Languages
@section Supporting Multiple Languages
guile-@var{version}.tar.gz. The current version is @value{VERSION}, so the
file you should grab is:
-@url{ftp://ftp.gnu.org/pub/gnu/guile/guile-@value{VERSION}.tar.gz}
+@url{ftp://ftp.gnu.org/gnu/guile/guile-@value{VERSION}.tar.gz}
To unbundle Guile use the instruction
Language Scheme}.
This will also be installed in your info directory.
+@node Organisation of this Manual
+@section Organisation of this Manual
+
+The rest of this manual is organised into the following chapters.
+
+@table @strong
+@item Chapter 2: Hello Guile!
+A whirlwind tour shows how Guile can be used interactively and as
+a script interpreter, how to link Guile into your own applications,
+and how to write modules of interpreted and compiled code for use with
+Guile. Everything introduced here is documented again and in full by
+the later parts of the manual.
+
+@item Chapter 3: Hello Scheme!
+For readers new to Scheme, this chapter provides an introduction to the basic
+ideas of the Scheme language. This material would apply to any Scheme
+implementation and so does not make reference to anything Guile-specific.
+
+@item Chapter 4: Programming in Scheme
+Provides an overview of programming in Scheme with Guile. It covers how to
+invoke the @code{guile} program from the command-line and how to write scripts
+in Scheme. It also introduces the extensions that Guile offers beyond standard
+Scheme.
+
+@item Chapter 5: Programming in C
+Provides an overview of how to use Guile in a C program. It
+discusses the fundamental concepts that you need to understand to
+access the features of Guile, such as dynamic types and the garbage
+collector. It explains in a tutorial like manner how to define new
+data types and functions for the use by Scheme programs.
+
+@item Chapter 6: Guile API Reference
+This part of the manual documents the Guile @acronym{API} in
+functionality-based groups with the Scheme and C interfaces presented
+side by side.
+
+@item Chapter 7: Guile Modules
+Describes some important modules, distributed as part of the Guile
+distribution, that extend the functionality provided by the Guile
+Scheme core.
+
+@item Chapter 8: GOOPS
+Describes GOOPS, an object oriented extension to Guile that provides
+classes, multiple inheritance and generic functions.
+
+@end table
+
@node Typographical Conventions
@section Typographical Conventions
HCoop / bpt / guile.git / blobdiff