@c essay @sp 10
@c essay @comment The title is printed in a large font.
@c essay @title Data Representation in Guile
-@c essay @subtitle $Id: data-rep.texi,v 1.2 2001-11-25 14:51:03 mvo Exp $
+@c essay @subtitle $Id: data-rep.texi,v 1.3 2002-01-08 08:29:00 ttn Exp $
@c essay @subtitle For use with Guile @value{VERSION}
@c essay @author Jim Blandy
@c essay @author Free Software Foundation
the @code{SCM} value. This may be significant when traversing lists, a
common activity in a Scheme system.
-Again, most real Scheme systems use a slighty different implementation;
+Again, most real Scheme systems use a slightly different implementation;
for example, if GET_PAIR subtracts off the low bits of @code{x}, instead
of masking them off, the optimizer will often be able to combine that
subtraction with the addition of the offset of the structure member we
includes small integers, characters, boolean values, the empty list, the
mysterious end-of-file object, and some others.
-The remaining types are called, not suprisingly, @dfn{non-immediates}.
+The remaining types are called, not surprisingly, @dfn{non-immediates}.
They include pairs, procedures, strings, vectors, and all other data
types in Guile.
contents.
@end deftypefun
-The macros below perform no typechecking. The results are undefined if
+The macros below perform no type checking. The results are undefined if
@var{cell} is an immediate. However, since all non-immediate Guile
objects are constructed from cells, and these macros simply return the
first element of a cell, they actually can be useful on datatypes other
A subr is a pointer to a C function, packaged up as a Scheme object to
make it callable by Scheme code. In addition to the function pointer,
the subr also contains a pointer to the name of the function, and
-information about the number of arguments accepted by the C fuction, for
+information about the number of arguments accepted by the C function, for
the sake of error checking.
There is no single type predicate macro that recognizes subrs, as
@node Non-immediate objects
@subsubsection Non-immediate objects
-A Scheme object of type @code{SCM} that does not fullfill the
+A Scheme object of type @code{SCM} that does not fulfill the
@code{SCM_IMP} predicate holds an encoded reference to a heap cell.
This reference can be decoded to a C pointer to a heap cell using the
@code{SCM2PTR} macro. The encoding of a pointer to a heap cell into a
@menu
* Describing a New Type::
* Creating Instances::
-* Typechecking::
+* Type checking::
* Garbage Collecting Smobs::
* A Common Mistake In Allocating Smobs::
* Garbage Collecting Simple Smobs::
Guile will apply this function to each instance of the new type it could
not find any live pointers to. The function should release all
resources held by the object and return the number of bytes released.
-This is analagous to the Java finalization method-- it is invoked at an
+This is analogous to the Java finalization method-- it is invoked at an
unspecified time (when garbage collection occurs) after the object is
dead. The default free function frees the smob data (if the size of the
struct passed to @code{scm_make_smob_type} is non-zero) using
to add a new smob type named @var{name}, with instance size @var{size} to the system.
It also registers the @var{mark}, @var{free}, @var{print}, @var{equalp} smob
special functions for that new type. Any of these parameters can be @code{NULL}
-to have that special function use the default behaviour for guile.
+to have that special function use the default behavior for guile.
The return value is a tag that is used in creating instances of the type. If @var{size}
is 0, then no memory will be allocated when instances of the smob are created, and
nothing will be freed by the default free function.
@end deftypefun
For example, here is how one might declare and register a new type
-representing eight-bit grayscale images:
+representing eight-bit gray-scale images:
@example
#include <libguile.h>
@end example
-@node Typechecking
-@subsection Typechecking
+@node Type checking
+@subsection Type checking
Functions that operate on smobs should aggressively check the types of
their arguments, to avoid misinterpreting some other datatype as a smob,
Note that you can use @code{gh_repl} inside @code{gh_enter} (in other
words, inside the code for @code{main-prog}) if you want the program to
-be controled by a Scheme read-eval-print loop.
+be controlled by a Scheme read-eval-print loop.
@end deftypefun
@cindex read eval print loop -- from the gh_ interface
First of all the C routine has to return type @code{SCM}.
-Second, all arguments passed to the C funcion will be of type
+Second, all arguments passed to the C function will be of type
@code{SCM}.
Third: the C routine is now subject to Scheme flow control, which means
@defmac GH_DEFER_INTS
@defmacx GH_ALLOW_INTS
-These macros disable and reenable Scheme's flow control. They
+These macros disable and re-enable Scheme's flow control. They
@end defmac
value)} @code{(vector-length v)} @code{(list->vector ls)} procedures.
The correspondence is not perfect for @code{gh_vector}: this routine
-taks a list @var{ls} instead of the individual list elements, thus
+takes a list @var{ls} instead of the individual list elements, thus
making it identical to @code{gh_list_to_vector}.
There is also a difference in gh_vector_length: the value returned is a
Look up a symbol with a given name, and return the object to which
it is bound. gh_lookup examines the Guile top level, and
- gh_module_lookup checks the module namespace specified by the
+ gh_module_lookup checks the module name space specified by the
`vec' argument.
The return value is the Scheme object to which SNAME is bound, or
@code{-lguile} in your link command. Libtool will expand this into
the needed linker options automatically. If you are not using
libtool, use the @code{guile-config} program to query the needed
-options explicitely. A linker command like
+options explicitly. A linker command like
@smallexample
$(CC) -o prog prog.o `guile-config link`
@sp 10
@comment The title is printed in a large font.
@title Guile Reference Manual
-@subtitle $Id: guile.texi,v 1.11 2002-01-02 23:59:00 ttn Exp $
+@subtitle $Id: guile.texi,v 1.12 2002-01-08 08:29:00 ttn Exp $
@subtitle For use with Guile @value{VERSION}
@c AUTHORS
@c accessing Guile objects.
@c Significant portions were contributed by Gary Houston (contributions
-@c to posix system calls and networking, expect, I/O internals and
+@c to POSIX system calls and networking, expect, I/O internals and
@c extensions, slib installation, error handling) and Tim Pierce
@c (sections on script interpreter triggers, alists, function tracing).
Part II: Programming with Guile
-* Programming Intro:: Intoduction to this part.
+* Programming Intro:: Introduction to this part.
* Programming Overview:: An overview of Guile programming.
* Scheme Intro:: Introduction to Guile Scheme.
* Basic Ideas:: Basic ideas in Scheme.
-@c $Id: intro.texi,v 1.7 2002-01-07 20:48:02 ossau Exp $
+@c $Id: intro.texi,v 1.8 2002-01-08 08:29:00 ttn Exp $
@page
For this to work, @code{load-extension} must be able to find
@file{libguile-bessel}, of course. It will look in the places that
are usual for your operating system, and it will additionally look
-into the directories listed in the @code{LTDL_LIBRRAY_PATH}
+into the directories listed in the @code{LTDL_LIBRARY_PATH}
environment variable.
To see how these Guile extensions via shared libraries relate to the
Advance to the next tabulator position.
@item ~y
-Pretty-print the correspinding @var{arg}.
+Pretty-print the corresponding @var{arg}.
@item ~a
Output the corresponding @var{arg} like @code{display}.
@item ~r
Output the corresponding @var{arg} as a number word, e.g. 10 prints as
@code{ten}. If prefixed with @code{:}, @code{tenth} is printed, if
-prefixed with @code{:@@}, roman numbers are printed.
+prefixed with @code{:@@}, Roman numbers are printed.
@item ~f
Output the corresponding @var{arg} as a fixed format floating point
@deffnx {C Function} scm_sys_compute_slots (class)
Return a list consisting of the names of all slots belonging to
class @var{class}, i. e. the slots of @var{class} and of all of
-its superclasses.
+its super-classes.
@end deffn
@deffn {Scheme Procedure} get-keyword key l default_value
@deffn {Scheme Procedure} method-generic-function obj
@deffnx {C Function} scm_method_generic_function (obj)
-Return the generic function fot the method @var{obj}.
+Return the generic function for the method @var{obj}.
@end deffn
@deffn {Scheme Procedure} generic-function-methods obj
@deffn {Scheme Procedure} class-direct-supers obj
@deffnx {C Function} scm_class_direct_supers (obj)
-Return the direct superclasses of the class @var{obj}.
+Return the direct super-classes of the class @var{obj}.
@end deffn
@deffn {Scheme Procedure} class-name obj
@item
Underscores in Unix procedure names are converted to hyphens.
@item
-Procedures which destructively modify Scheme data have exclaimation
+Procedures which destructively modify Scheme data have exclamation
marks appended, e.g., @code{recv!}.
@item
Predicates (returning only @code{#t} or @code{#f}) have question marks
A file descriptor can be extracted from a port and a new port can be
created from a file descriptor. However a file descriptor is just an
-integer and the garbage collector doesn't recognise it as a reference
+integer and the garbage collector doesn't recognize it as a reference
to the port. If all other references to the port were dropped, then
it's likely that the garbage collector would free the port, with the
side-effect of closing the file descriptor prematurely.
associated "revealed count" which can be used to keep track of how many
times the underlying file descriptor has been stored in other places.
If a port's revealed count is greater than zero, the file descriptor
-will not be closed when the port is gabage collected. A programmer
+will not be closed when the port is garbage collected. A programmer
can therefore ensure that the revealed count will be greater than
zero if the file descriptor is needed elsewhere.
except for those supplied as arguments. This procedure
was intended to be used before an exec call to close file descriptors
which are not needed in the new process. However it has the
-undesirable side-effect of flushing buffes, so it's deprecated.
+undesirable side-effect of flushing buffers, so it's deprecated.
Use port-for-each instead.
@end deffn
it to one of the other operations.
@end table
The return value is not specified. @var{file} may be an open
-file descriptor or an open file descriptior port.
+file descriptor or an open file descriptor port.
@end deffn
@deffn {Scheme Procedure} select reads writes excepts [secs [usecs]]
@deffnx {C Function} scm_select (reads, writes, excepts, secs, usecs)
This procedure has a variety of uses: waiting for the ability
-to provide input, accept output, or the existance of
+to provide input, accept output, or the existence of
exceptional conditions on a collection of ports or file
descriptors, or waiting for a timeout to occur.
It also returns if interrupted by a signal.
@deffnx {C Function} scm_basename (filename, suffix)
Return the base name of the file name @var{filename}. The
base name is the file name without any directory components.
-If @var{suffix} is privided, and is equal to the end of
+If @var{suffix} is provided, and is equal to the end of
@var{basename}, it is removed also.
@end deffn
@item group:gid
The group id number.
@item group:mem
-A list of userids which have this group as a supplimentary group.
+A list of userids which have this group as a supplementary group.
@end table
@deffn {Scheme Procedure} getgrgid gid
-Look up an integer groupid in the group database.
+Look up an integer group id in the group database.
@end deffn
@deffn {Scheme Procedure} getgrnam name
@deffn {Scheme Procedure} umask [mode]
@deffnx {C Function} scm_umask (mode)
-If @var{mode} is omitted, retuns a decimal number representing the current
+If @var{mode} is omitted, returns a decimal number representing the current
file creation mask. Otherwise the file creation mask is set to
@var{mode} and the previous value is returned.
@deffn {Scheme Procedure} getgroups
@deffnx {C Function} scm_getgroups ()
Return a vector of integers representing the current
-supplimentary group IDs.
+supplementary group IDs.
@end deffn
@deffn {Scheme Procedure} getppid
@deffnx {C Function} scm_execl (filename, args)
Executes the file named by @var{path} as a new process image.
The remaining arguments are supplied to the process; from a C program
-they are accessable as the @code{argv} argument to @code{main}.
+they are accessible as the @code{argv} argument to @code{main}.
Conventionally the first @var{arg} is the same as @var{path}.
All arguments must be strings.
@deffn {Scheme Procedure} shutdown sock how
@deffnx {C Function} scm_shutdown (sock, how)
Sockets can be closed simply by using @code{close-port}. The
-@code{shutdown} procedure allows reception or tranmission on a
+@code{shutdown} procedure allows reception or transmission on a
connection to be shut down individually, according to the parameter
@var{how}:
@deffnx {C Function} scm_getsockname (sock)
Return the address of @var{sock}, in the same form as the
object returned by @code{accept}. On many systems the address
-of a socket in the @code{AF_FILE} namespace cannot be read.
+of a socket in the @code{AF_FILE} name space cannot be read.
@end deffn
@deffn {Scheme Procedure} getpeername sock
Return the address that @var{sock}
is connected to, in the same form as the object returned by
@code{accept}. On many systems the address of a socket in the
-@code{AF_FILE} namespace cannot be read.
+@code{AF_FILE} name space cannot be read.
@end deffn
@deffn {Scheme Procedure} recv! sock buf [flags]
Otherwise the specified locale category is set to the string
@var{locale} and the new value is returned as a
system-dependent string. If @var{locale} is an empty string,
-the locale will be set using envirionment variables.
+the locale will be set using environment variables.
@end deffn
@node Encryption
playing adventure games. The only limitation is that extensions are
restricted to the functionality provided by Emacs's built-in set of
primitive operations. For example, you can interact and display data by
-manipulating the contents of an Emacs buffer, but you can't popup and
+manipulating the contents of an Emacs buffer, but you can't pop-up and
draw a window with a layout that is totally different to the Emacs
standard.
personal startup file.
You will notice that the REPL's behaviour changes a bit when you have
-loaded the readline module. For examle, when you press Enter before
+loaded the readline module. For example, when you press Enter before
typing in the closing parentheses of a list, you will see the
@dfn{continuation} prompt, three dots: @code{...} This gives you a nice
visual feedback when trying to match parentheses. To make this even
easier, @dfn{bouncing parentheses} are implemented. That means that
when you type in a closing parentheses, the cursor will jump to the
-corresponding opening paren for a short time, making it trivial to make
+corresponding opening parenthesis for a short time, making it trivial to make
them match.
Once the readline module is activated, all lines entered interactively
internal definitions is the @strong{complete} body of the
@code{let}-expression, the @code{lambda}-expression which gets bound
to the variable @code{banana} may refer to the variable @code{apple},
-even thogh it's definition appears lexically @emph{after} the definition
+even though it's definition appears lexically @emph{after} the definition
of @code{banana}. This is because a sequence of internal definition
acts as if it were a @code{letrec} expression.
@node Binding Reflection
@section Querying variable bindings
-Guile provides a procedure for checking wehther a symbol is bound in the
+Guile provides a procedure for checking whether a symbol is bound in the
top level environment. If you want to test whether a symbol is locally
bound in expression, you can use the @code{bound?} macro from the module
@code{(ice-9 optargs)}, documented in @ref{Optional Arguments}.
consisting of the two numbers 1 and 2, and a pair containing the symbols
@code{foo} and @code{bar} can be entered. It is very important to write
the whitespace before and after the dot, because otherwise the Scheme
-parser whould not be able to figure out where to split the tokens.
+parser would not be able to figure out where to split the tokens.
@lisp
(1 . 2)
Note that @code{list-copy} only makes a copy of the pairs which make up
the spine of the lists. The list elements are not copied, which means
-that modifying the elements of the new list also modyfies the elements
+that modifying the elements of the new list also modifies the elements
of the old list. On the other hand, applying procedures like
@code{set-cdr!} or @code{delv!} to the new list will not alter the old
list. If you also need to copy the list elements (making a deep copy),
Vtables, themselves structures, are first class representations of
disjoint sub-types of structures in general. In most cases, when a
-new structure is created, programmers must specifiy a vtable for the
+new structure is created, programmers must specify a vtable for the
new structure. Each vtable has a field describing the layout of its
instances. Vtables can have additional, user-defined fields as well.
@end itemize
created with this type of field, the field is initialized to refer to
the structure's own handle. This kind of field is mainly useful when
mixing Scheme and C code in which the C code may need to compute a
-structure's handle given only the address of its malloced data.
+structure's handle given only the address of its malloc-ed data.
@end itemize
In the above example, field 0 contains the size of the vector and
fields beginning at 1 contain the vector elements.
-A kind of tagged vector (a constant tag followed by conventioal
+A kind of tagged vector (a constant tag followed by conventional
vector elements) might be:
@example
@subsubsection Alist Key Equality
All of Guile's dedicated association list procedures, apart from
-@code{acons}, come in three flavours, depending on the level of equality
+@code{acons}, come in three flavors, depending on the level of equality
that is required to decide whether an existing key in the association
list is the same as the key that the procedure call uses to identify the
required entry.
@deffnx {C Function} scm_assq_set_x (alist, key, val)
@deffnx {C Function} scm_assv_set_x (alist, key, val)
@deffnx {C Function} scm_assoc_set_x (alist, key, val)
-Reassociate @var{key} in @var{alist} with @var{value}: find any existing
+Re-associate @var{key} in @var{alist} with @var{value}: find any existing
@var{alist} entry for @var{key} and associate it with the new
@var{value}. If @var{alist} does not contain an entry for @var{key},
add a new one. Return the (possibly new) alist.
@deffn {Scheme Procedure} hashq key size
@deffnx {C Function} scm_hashq (key, size)
Determine a hash value for @var{key} that is suitable for
-lookups in a hashtable of size @var{size}, where @code{eq?} is
+lookups in a hash table of size @var{size}, where @code{eq?} is
used as the equality predicate. The function returns an
integer in the range 0 to @var{size} - 1. Note that
@code{hashq} may use internal addresses. Thus two calls to
@deffn {Scheme Procedure} hashv key size
@deffnx {C Function} scm_hashv (key, size)
Determine a hash value for @var{key} that is suitable for
-lookups in a hashtable of size @var{size}, where @code{eqv?} is
+lookups in a hash table of size @var{size}, where @code{eqv?} is
used as the equality predicate. The function returns an
integer in the range 0 to @var{size} - 1. Note that
@code{(hashv key)} may use internal addresses. Thus two calls
@deffn {Scheme Procedure} hash key size
@deffnx {C Function} scm_hash (key, size)
Determine a hash value for @var{key} that is suitable for
-lookups in a hashtable of size @var{size}, where @code{equal?}
+lookups in a hash table of size @var{size}, where @code{equal?}
is used as the equality predicate. The function returns an
integer in the range 0 to @var{size} - 1.
@end deffn
@deffn syntax if test consequent [alternate]
All arguments may be arbitrary expressions. First, @var{test} is
evaluated. If it returns a true value, the expression @var{consequent}
-is evaluated and @var{alternate} is ignoret. If @var{test} evaluates to
+is evaluated and @var{alternate} is ignored. If @var{test} evaluates to
@code{#f}, @var{alternate} is evaluated instead. The value of the
evaluated branch (@var{consequent} or @var{alternate}) is returned as
the value of the @code{if} expression.
All @var{datum}s must be distinct. First, @var{key} is evaluated. The
the result of this evaluation is compared against all @var{datum}s using
-@code{eqv?}. When this comparison succeeds, the epression(s) following
+@code{eqv?}. When this comparison succeeds, the expression(s) following
the @var{datum} are evaluated from left to right, returning the value of
the last expression as the result of the @code{case} expression.
This is quite different to other languages which only allow
single-value returns. Returning multiple values is different from
returning a list (or pair or vector) of values to the caller, because
-conceptionally not @emph{one} compound object is returned, but several
+conceptually not @emph{one} compound object is returned, but several
distinct values.
The primitive procedures for handling multiple values are @code{values}
@itemize @bullet
@item
@code{error-signal}: thrown after receiving an unhandled fatal signal
-such as SIGSEV, SIGBUS, SIGFPE etc. The @var{rest} argument in the throw
+such as SIGSEGV, SIGBUS, SIGFPE etc. The @var{rest} argument in the throw
contains the coded signal number (at present this is not the same as the
usual Unix signal number).
accepted domain.
@item
-@code{wrong-type-arg}: an argument to a procedure has the wrong thpe.
+@code{wrong-type-arg}: an argument to a procedure has the wrong type.
@item
@code{wrong-number-of-args}: a procedure was called with the wrong number
module system.
@end itemize
-The contents of this chapter are, therefore, a matter of judgement. By
+The contents of this chapter are, therefore, a matter of judgment. By
@dfn{generic}, we mean to select those data types whose typical use as
@emph{data} in a wide variety of programming contexts is more important
than their use in the implementation of a particular piece of
@c begin (texi-doc-string "guile" "min")
@deffn {Scheme Procedure} min x1 x2 @dots{}
-Return the minium of all parameter values.
+Return the minimum of all parameter values.
@end deffn
@c begin (texi-doc-string "guile" "truncate")
@deffn {Scheme Procedure} integer-length n
@deffnx {C Function} scm_integer_length (n)
-Return the number of bits neccessary to represent @var{n}.
+Return the number of bits necessary to represent @var{n}.
@lisp
(integer-length #b10101010)
even the NUL character @code{'\0'}. But note: Since most operating
system calls dealing with strings (such as for file operations) expect
strings to be zero-terminated, they might do unexpected things when
-called with string containing unusal characters.
+called with string containing unusual characters.
@menu
* String Syntax:: Read syntax for strings.
@menu
* Regexp Functions:: Functions that create and match regexps.
* Match Structures:: Finding what was matched by a regexp.
-* Backslash Escapes:: Removing the special meaning of regexp metacharacters.
+* Backslash Escapes:: Removing the special meaning of regexp
+ meta-characters.
@end menu
[FIXME: it may be useful to include an Examples section. Parts of this
@itemize @bullet
@item
-colour depth -- Default: the colour depth for the screen
+color depth -- Default: the color depth for the screen
@item
-background colour -- Default: white
+background color -- Default: white
@item
width -- Default: 600
for that argument:
@lisp
-(make-window 'default ;; Colour depth
- 'default ;; Background colour
+(make-window 'default ;; Color depth
+ 'default ;; Background color
800 ;; Width
100 ;; Height
@dots{}) ;; More make-window arguments
@deffnx {C Function} scm_display_error (stack, port, subr, message, args, rest)
Display an error message to the output port @var{port}.
@var{stack} is the saved stack for the error, @var{subr} is
-the name of the procedure in which the error occured and
+the name of the procedure in which the error occurred and
@var{message} is the actual error message, which may contain
formatting instructions. These will format the arguments in
the list @var{args} accordingly. @var{rest} is currently
@node Latent Typing
@subsection Latent Typing
-The term @dfn{latent typing} is used to descibe a computer language,
+The term @dfn{latent typing} is used to describe a computer language,
such as Scheme, for which you cannot, @emph{in general}, simply look at
a program's source code and determine what type of data will be
associated with a particular variable, or with the result of a
@end lisp
The key point here is that the code does not create any local binding
-for the identifier @code{currency-abbreviation}, so all occurences of
+for the identifier @code{currency-abbreviation}, so all occurrences of
this identifier refer to the top level variable.
Special treatment is required for ports which can be seeked at random.
Before various operations, such as seeking the port or changing from
input to output on a bidirectional port or vice versa, the port
-implemention must be given a chance to update its state. The write
+implementation must be given a chance to update its state. The write
buffer is updated by calling the @code{flush} ptob procedure and the
input buffer is updated by calling the @code{end_input} ptob procedure.
In the case of an fport, @code{flush} causes buffered output to be
Set using @code{scm_set_port_flush}.
@item end_input
-Perform any synchronisation required when switching from input to output
+Perform any synchronization required when switching from input to output
on the port. Reset the value of @code{rw_active} to @code{SCM_PORT_NEITHER}.
Set using @code{scm_set_port_end_input}.
the additional information automatically disappears when the original
data is no longer in use and gets garbage collected. In a weak key hash,
the hash entry for that key disappears as soon as the key is no longer
-referneced from anywhere else. For weak value hashes, the same happens
+referenced from anywhere else. For weak value hashes, the same happens
as soon as the value is no longer in use. Entries in a doubly weak hash
disappear when either the key or the value are not used anywhere else
anymore.
@c from here?
@item (ice-9 jacal)
This module contains hooks for using Aubrey Jaffer's symbolic math
-packge Jacal from Guile (@pxref{JACAL}).
+package Jacal from Guile (@pxref{JACAL}).
@end table
@subsection Low level dynamic linking
When using the low level procedures to do your dynamic linking, you have
-complete control over which library is loaded when and what get's done
+complete control over which library is loaded when and what gets done
with it.
@deffn {Scheme Procedure} dynamic-link library
indicated by @var{name}. Each definition that is added to it will be
automatically exported.
-The string @var{name} indicates the hierachical name of the new module.
+The string @var{name} indicates the hierarchical name of the new module.
It should consist of the individual components of the module name
separated by single spaces. That is, the Scheme module name @code{(foo
bar)}, which is a list, should be written as @code{"foo bar"} for the
@menu
* Lambda:: Basic procedure creation using lambda.
* Optional Arguments:: Handling keyword, optional and rest arguments.
-* Procedure Properties:: Procedure properties and metainformation.
+* Procedure Properties:: Procedure properties and meta-information.
* Procedures with Setters:: Procedures with setters.
* Macros:: Lisp style macro definitions.
* Syntax Rules:: Support for R5RS @code{syntax-rules}.
stored into the newly created location for the formal variable.
@item (@var{variable1} @dots{} @var{variablen} . @var{variablen+1})
If a space-delimited period precedes the last variable, then the
-procedure takes @var{n} or more variablesm where @var{n} is the number
+procedure takes @var{n} or more variables where @var{n} is the number
of formal arguments before the period. There must be at least one
argument before the period. The first @var{n} actual arguments will be
stored into the newly allocated locations for the first @var{n} formal
@end example
The characters `*', `+' and `?' are not to be taken literally; they mean
-respectively, zero or more occurences, one or more occurences, and one
-or zero occurences.
+respectively, zero or more occurrences, one or more occurrences, and one
+or zero occurrences.
@deffn {library syntax} lambda* formals body
@code{lambda*} creates a procedure that takes optional arguments. These
are specified by putting them inside brackets at the end of the
-paramater list, but before any dotted rest argument. For example,
+parameter list, but before any dotted rest argument. For example,
@lisp
(lambda* (a b #:optional c d . e) '())
(display (list y z u)))
@end lisp
defines a procedure @code{x} with a fixed argument @var{y}, an optional
-agument @var{a}, another optional argument @var{z} with default value 3,
+argument @var{a}, another optional argument @var{z} with default value 3,
a keyword argument @var{w}, and a rest argument @var{u}.
@lisp
@deffn {library syntax} defmacro* name formals body
@deffnx {library syntax} defmacro*-public name formals body
These are just like @code{defmacro} and @code{defmacro-public} except that they
-take @code{lambda*}-style extended paramter lists, where @code{#:optional},
+take @code{lambda*}-style extended parameter lists, where @code{#:optional},
@code{#:key}, @code{#:allow-other-keys} and @code{#:rest} are allowed with the usual
semantics. Here is an example of a macro with an optional argument:
@node Procedure Properties
-@section Procedure Properties and Metainformation
+@section Procedure Properties and Meta-information
@c FIXME::martin: Review me!
Procedures always have attached the environment in which they were
created and information about how to apply them to actual arguments. In
-addition to that, properties and metainformation can be stored with
+addition to that, properties and meta-information can be stored with
procedures. The procedures in this section can be used to test whether
a given procedure satisfies a condition; and to access and set a
procedure's property.
@cindex procedure with setter
@cindex setter
A @dfn{procedure with setter} is a special kind of procedure which
-normally behaves like any accesor procedure, that is a procedure which
+normally behaves like any accessor procedure, that is a procedure which
accesses a data structure. The difference is that this kind of
procedure has a so-called @dfn{setter} attached, which is a procedure
for storing something into a data structure.
@node Internal Macros
@section Internal Representation of Macros and Syntax
-Internally, Guile uses three different flavours of macros. The three
-flavours are called @dfn{acro} (or @dfn{syntax}), @dfn{macro} and
+Internally, Guile uses three different flavors of macros. The three
+flavors are called @dfn{acro} (or @dfn{syntax}), @dfn{macro} and
@dfn{mmacro}.
Given the expression
@end lisp
@noindent
-with @code{foo} being some flavour of macro, one of the following things
+with @code{foo} being some flavor of macro, one of the following things
will happen when the expression is evaluated.
@itemize @bullet
of the containing code.
@end deffn
-In the following primitives, @dfn{acro} flavour macros are referred to
+In the following primitives, @dfn{acro} flavor macros are referred to
as @dfn{syntax transformers}.
@deffn {Scheme Procedure} macro? obj
@end deffn
@deffn {Scheme Procedure} nil-eq x y
-Compare @var{x} and @var{y} and return LISP's t if they are
-@code{eq?}, return LISP's nil otherwise.
+Compare @var{x} and @var{y} and return Lisp's t if they are
+@code{eq?}, return Lisp's nil otherwise.
@end deffn
@deffn {Scheme Procedure} null x
@deffnx {C Function} scm_null (x)
-Return LISP's @code{t} if @var{x} is nil in the LISP sense,
-return LISP's nil otherwise.
+Return Lisp's @code{t} if @var{x} is nil in the LISP sense,
+return Lisp's nil otherwise.
@end deffn
@menu
* Equality:: When are two values `the same'?
-* Property Lists:: Managing metainformation about Scheme objects.
+* Property Lists:: Managing meta-information about Scheme objects.
* Primitive Properties:: A modern interface to object properties.
* Sorting:: Sort utility procedures.
* Copying:: Copying deep structures.
@subsection Structuring argument lists for C functions
The C function's arguments will be all of the Scheme procedure's
-argumements, both required and optional; if the Scheme procedure takes a
+arguments, both required and optional; if the Scheme procedure takes a
``rest'' argument, that will be a final argument to the C function. The
C function's arguments, as well as its return type, will be @code{SCM}.
@end example
@item
-Use Guile to create the catalogue file, e.g.,:
+Use Guile to create the catalog file, e.g.,:
@example
# guile
guile> (quit)
@end example
-The catalogue data should now be in
+The catalog data should now be in
@code{/usr/local/share/guile/site/slibcat}.
If instead you get an error such as:
Since @code{cond-expand} is needed to tell what a Scheme implementation
provides, it must be accessible without using any
-implementation-dependant operations, such as @code{use-modules} in
+implementation-dependent operations, such as @code{use-modules} in
Guile. Thus, it is not necessary to use any module to get access to
this form.
* SRFI-1 Length Append etc:: Length calculation and list appending.
* SRFI-1 Fold and Map:: Higher-order list processing.
* SRFI-1 Filtering and Partitioning:: Filter lists based on predicates.
-* SRFI-1 Searching:: Search for elments.
+* SRFI-1 Searching:: Search for elements.
* SRFI-1 Deleting:: Delete elements from lists.
* SRFI-1 Association Lists:: Handle association lists.
* SRFI-1 Set Operations:: Use lists for representing sets.
@deffn {Scheme Procedure} null-list? lst
Return @code{#t} if @var{lst} is the empty list @code{()}, @code{#f}
otherwise. If something else than a proper or circular list is passed
-as @var{lst}, an error is signalled. This procedure is recommented
+as @var{lst}, an error is signalled. This procedure is recommended
for checking for the end of a list in contexts where dotted lists are
not allowed.
@end deffn
specified. This procedure is extended with respect to R5RS, because
the argument lists may have different lengths. The shortest argument
list determines the number of times @var{f} is called. @var{f} will
-be applied to tge list elements in left-to-right order.
+be applied to the list elements in left-to-right order.
@end deffn
Apply @var{pred} across the lists and return a true value if the
predicate returns true for any of the list elements(s); return
@code{#f} otherwise. The true value returned is always the result of
-the first succesful application of @var{pred}.
+the first successful application of @var{pred}.
@end deffn
@deffn {Scheme Procedure} every pred lst1 lst2 @dots{}
Apply @var{pred} across the lists and return a true value if the
predicate returns true for every of the list elements(s); return
@code{#f} otherwise. The true value returned is always the result of
-the final succesful application of @var{pred}.
+the final successful application of @var{pred}.
@end deffn
@deffn {Scheme Procedure} list-index pred lst1 lst2 @dots{}
Lists can be used for representing sets of objects. The procedures
documented in this section can be used for such set representations.
-Man combinding several sets or adding elements, they make sure that no
+Man combining several sets or adding elements, they make sure that no
object is contained more than once in a given list. Please note that
lists are not a too efficient implementation method for sets, so if
you need high performance, you should think about implementing a
@end example
where @var{ctor} must be a symbol for which a read constructor was
-defined previouly, using @code{define-reader-ctor}.
+defined previously, using @code{define-reader-ctor}.
Example:
* SRFI-13 Constructors:: String constructing procedures.
* SRFI-13 List/String Conversion:: Conversion from/to lists.
* SRFI-13 Selection:: Selection portions of strings.
-* SRFI-13 Modification:: Modfify strings in-place.
+* SRFI-13 Modification:: Modify strings in-place.
* SRFI-13 Comparison:: Compare strings.
* SRFI-13 Prefixes/Suffixes:: Detect common pre-/suffixes.
* SRFI-13 Searching:: Searching for substrings.
@deffn {Scheme Procedure} string-index s char_pred [start end]
@deffnx {Scheme Procedure} string-index-right s char_pred [start end]
Search through the string @var{s} from left to right (right to left),
-returning the index of the first (last) occurence of a character which
+returning the index of the first (last) occurrence of a character which
@itemize @bullet
@item
equals @var{char_pred}, if it is character,
@item
-satisifies the predicate @var{char_pred}, if it is a
+satisfies the predicate @var{char_pred}, if it is a
procedure,
@item
@deffn {Scheme Procedure} string-skip s char_pred [start end]
@deffnx {Scheme Procedure} string-skip-right s char_pred [start end]
Search through the string @var{s} from left to right (right to left),
-returning the index of the first (last) occurence of a character which
+returning the index of the first (last) occurrence of a character which
@itemize @bullet
@item
does not equal @var{char_pred}, if it is character,
@item
-does not satisify the predicate @var{char_pred}, if it is
+does not satisfy the predicate @var{char_pred}, if it is
a procedure.
@item
equals @var{char_pred}, if it is character,
@item
-satisifies the predicate @var{char_pred}, if it is a procedure.
+satisfies the predicate @var{char_pred}, if it is a procedure.
@item
is in the set @var{char_pred}, if it is a character set.
* SRFI-14 Character Set Data Type:: Underlying data type for charsets.
* SRFI-14 Predicates/Comparison:: Charset predicates.
* SRFI-14 Iterating Over Character Sets:: Enumerate charset elements.
-* SRFI-14 Creating Character Sets:: Makeing new charsets.
+* SRFI-14 Creating Character Sets:: Making new charsets.
* SRFI-14 Querying Character Sets:: Test charsets for membership etc.
* SRFI-14 Character-Set Algebra:: Calculating new charsets.
* SRFI-14 Standard Character Sets:: Variables containing predefined charsets.
If @var{error} is a true value, an error is signalled if the
specified range contains characters which are not contained in
the implemented character range. If @var{error} is @code{#f},
-these characters are silently left out of the resultung
+these characters are silently left out of the resulting
character set.
The characters in @var{base_cs} are added to the result, if
HCoop / bpt / guile.git / commitdiff