Guile NEWS --- history of user-visible changes.
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
See the end for copying conditions.
Please send Guile bug reports to bug-guile@gnu.org.
-\f
-(During the 1.9 series, we will keep an incremental NEWS for the latest
-prerelease, and a full NEWS corresponding to 1.8 -> 2.0.)
-Changes in 1.9.6 (since the 1.9.5 prerelease):
+Note: During the 1.9 series, we will keep an incremental NEWS for the
+latest prerelease, and a full NEWS corresponding to 1.8 -> 2.0.
+
+Changes in 1.9.14 (since the 1.9.13 prerelease):
+
+** New module: `(ice-9 futures)'.
+
+See "Futures" in the manual, for more information.
+
+** Add bindings to GNU `sched_setaffinity' and `sched_getaffinity'.
+
+See "Processes" in the manual, for more information.
+
+** New module `(srfi srfi-38)', External Representation for Data With Shared Structure
+
+See "SRFI-38" in the manual, for more information. Thanks to Andreas
+Rottmann.
+
+** New module: `(web uri)', URI data type, parser, and unparser
+** New module: `(web http)', HTTP header parsers and unparsers
+** New module: `(web request)', HTTP request data type, reader, and writer
+** New module: `(web response)', HTTP response data type, reader, and writer
+** New module: `(web server)', Generic HTTP server
+** New module: `(ice-9 poll)', a poll wrapper
+** New module: `(web server http)', HTTP-over-TCP web server implementation
+
+These modules are as yet without documentation. But try the following
+command line:
+
+ meta/guile examples/web/debug-sxml.scm
+
+Then visit localhost:8080 in your web browser. Let us know how it goes!
+
+** Better Emacs Lisp implementation
+
+Brian Templeton's Summer-of-Code work was finally merged in, which
+should improve the state of Guile's Elisp support. There is still some
+work to do, so patches are welcome!
+
+** R6RS fixes
+
+There were many fixes and enhancements to the R6RS support. Thanks to
+Julian Graham, Andreas Rottmann, and Göran Weinholt.
+
+** Expression-oriented readline history
+
+Guile's readline history now tries to operate on expressions instead of
+input lines. Let us know what you think!
+
+** Better syntax errors
+
+The Scheme expander, Ecmascript compiler, and other language
+implementations now produce more useful syntax errors. The default
+error handlers print them out more nicely now.
+
+** Lots of documentation updates
+
+In particular, the documentation for GOOPS and regular expressions has
+seen some work. Unfortunately the code has come too fast and furious
+for full documentary folios, so some of the new modules are still
+undocumented.
+
+** Better pretty-printing
+
+Indentation recognizes more special forms, like `syntax-case', and read
+macros like `quote' are printed better.
+
+** Multicast socket options
+
+FIXME: Need to document IP_MULTICAST_TTL and IP_MULTICAST_IF in the
+manual.
+
+** Deprecate `cuserid'
+
+`cuserid' has been deprecated, as it only returns 8 bytes of a user's
+login. Use `(passwd:name (getpwuid (geteuid)))' instead.
+
+** New procedure. `reload-module'
+
+Needs documenting and a REPL meta-command.
+
+** Allow user-defined REPL meta-commands
+
+See FIXME in the manual, for more information.
+
+** Add support for unbound fluids
+
+FIXME: needs documentation
+
+See `make-undefined-fluid' (FIXME: should be make-unbound-fluid),
+`fluid-unset!', and `fluid-bound?' in the manual.
+
+** Add variable-unset!
+
+FIXME: document.
+
+** Command line additions
+
+The guile binary now supports a new switch "-x", which can be used to
+extend the list of filename extensions tried when loading files
+(%load-extensions).
** And of course, the usual collection of bugfixes
* New modules (see the manual for details)
** `(srfi srfi-18)', more sophisticated multithreading support
+** `(srfi srfi-27)', sources of random bits
+** `(srfi srfi-42)', eager comprehensions
+** `(srfi srfi-45)', primitives for expressing iterative lazy algorithms
+** `(srfi srfi-67)', compare procedures
** `(ice-9 i18n)', internationalization support
-** `(rnrs bytevector)', the R6RS bytevector API
+** `(rnrs bytevectors)', the R6RS bytevector API
** `(rnrs io ports)', a subset of the R6RS I/O port API
** `(system xref)', a cross-referencing facility (FIXME undocumented)
+** `(ice-9 vlist)', lists with constant-time random access; hash lists
+** `(system foreign)', foreign function interface
+** `(sxml match)', a pattern matcher for SXML
+** `(srfi srfi-9 gnu)', extensions to the SRFI-9 record library
+** `(system vm coverage)', a line-by-line code coverage library
+
+** Replaced `(ice-9 match)' with Alex Shinn's compatible, hygienic matcher.
+
+Guile's copy of Andrew K. Wright's `match' library has been replaced by
+a compatible hygienic implementation by Alex Shinn. It is now
+documented, see "Pattern Matching" in the manual.
+
+Compared to Andrew K. Wright's `match', the new `match' lacks
+`match-define', `match:error-control', `match:set-error-control',
+`match:error', `match:set-error', and all structure-related procedures.
+
+** Imported statprof, SSAX, and texinfo modules from Guile-Lib
+
+The statprof statistical profiler, the SSAX XML toolkit, and the texinfo
+toolkit from Guile-Lib have been imported into Guile proper. See
+"Standard Library" in the manual for more details.
+
+** Integration of lalr-scm, a parser generator
+
+Guile has included Dominique Boucher's fine `lalr-scm' parser generator
+as `(system base lalr)'. See "LALR(1) Parsing" in the manual, for more
+information.
* Changes to the stand-alone interpreter
Compiled code loads much faster than Scheme source code, and runs around
3 or 4 times as fast, generating much less garbage in the process.
-** The stack limit is now initialized from the environment.
+** Evaluating Scheme code does not use the C stack.
-If getrlimit(2) is available and a stack limit is set, Guile will set
-its stack limit to 80% of the rlimit. Otherwise the limit is 160000
-words, a four-fold increase from the earlier default limit.
+Besides when compiling Guile itself, Guile no longer uses a recursive C
+function as an evaluator. This obviates the need to check the C stack
+pointer for overflow. Continuations still capture the C stack, however.
** New environment variables: GUILE_LOAD_COMPILED_PATH,
GUILE_SYSTEM_LOAD_COMPILED_PATH
** New read-eval-print loop (REPL) implementation
-Running Guile with no arguments drops the user into the new REPL. While
-it is self-documenting to an extent, the new REPL has not yet been
-documented in the manual. This will be fixed before 2.0.
+Running Guile with no arguments drops the user into the new REPL. See
+"Using Guile Interactively" in the manual, for more information.
+
+** Remove old Emacs interface
+
+Guile had an unused `--emacs' command line argument that was supposed to
+help when running Guile inside Emacs. This option has been removed, and
+the helper functions `named-module-use!' and `load-emacs-interface' have
+been deprecated.
+
+** Add `(system repl server)' module and `--listen' command-line argument
+
+The `(system repl server)' module exposes procedures to listen on
+sockets for connections, and serve REPLs to those clients. The --listen
+command-line argument allows any Guile program to thus be remotely
+debuggable.
+
+See "Invoking Guile" for more information on `--listen'.
+
+** New reader options: `square-brackets' and `r6rs-hex-escapes'
+
+The reader supports a new option (changeable via `read-options'),
+`square-brackets', which instructs it to interpret square brackets as
+parentheses. This option is on by default.
+
+When the new `r6rs-hex-escapes' reader option is enabled, the reader
+will recognize string escape sequences as defined in R6RS. R6RS string
+escape sequences are incompatible with Guile's existing escapes, though,
+so this option is off by default.
+
+** Function profiling and tracing at the REPL
+
+The `,profile FORM' REPL meta-command can now be used to statistically
+profile execution of a form, to see which functions are taking the most
+time. See `,help profile' for more information.
+
+Similarly, `,trace FORM' traces all function applications that occur
+during the execution of `FORM'. See `,help trace' for more information.
+
+** Recursive debugging REPL on error
+
+When Guile sees an error at the REPL, instead of saving the stack, Guile
+will directly enter a recursive REPL in the dynamic context of the
+error. See "Error Handling" in the manual, for more information.
+
+A recursive REPL is the same as any other REPL, except that it
+has been augmented with debugging information, so that one can inspect
+the context of the error. The debugger has been integrated with the REPL
+via a set of debugging meta-commands.
+
+For example, one may access a backtrace with `,backtrace' (or
+`,bt'). See "Interactive Debugging" in the manual, for more
+information.
** New `guile-tools' commands: `compile', `disassemble'
Backtraces may now be disclosed with the keyboard in addition to the
mouse.
+** Load path change: search in version-specific paths before site paths
+
+When looking for a module, Guile now searches first in Guile's
+version-specific path (the library path), *then* in the site dir. This
+allows Guile's copy of SSAX to override any Guile-Lib copy the user has
+installed. Also it should cut the number of `stat' system calls by half,
+in the common case.
+
+** Value history in the REPL on by default
+
+By default, the REPL will save computed values in variables like `$1',
+`$2', and the like. There are programmatic and interactive interfaces to
+control this. See "Value History" in the manual, for more information.
+
+** Readline tab completion for arguments
+
+When readline is enabled, tab completion works for arguments too, not
+just for the operator position.
+
+** Interactive Guile follows GNU conventions
+
+As recommended by the GPL, Guile now shows a brief copyright and
+warranty disclaimer on startup, along with pointers to more information.
+
* Changes to Scheme functions and syntax
+** Support for R6RS libraries
+
+The `library' and `import' forms from the latest Scheme report have been
+added to Guile, in such a way that R6RS libraries share a namespace with
+Guile modules. R6RS modules may import Guile modules, and are available
+for Guile modules to import via use-modules and all the rest. See "R6RS
+Libraries" in the manual for more information.
+
+** Implementations of R6RS libraries
+
+Guile now has implementations for all of the libraries defined in the
+R6RS. Thanks to Julian Graham for this excellent hack. See "R6RS
+Standard Libraries" in the manual for a full list of libraries.
+
+** Partial R6RS compatibility
+
+Guile now has enough support for R6RS to run a reasonably large subset
+of R6RS programs.
+
+Guile is not fully R6RS compatible. Many incompatibilities are simply
+bugs, though some parts of Guile will remain R6RS-incompatible for the
+foreseeable future. See "R6RS Incompatibilities" in the manual, for more
+information.
+
+Please contact bug-guile@gnu.org if you have found an issue not
+mentioned in that compatibility list.
+
+** New implementation of `primitive-eval'
+
+Guile's `primitive-eval' is now implemented in Scheme. Actually there is
+still a C evaluator, used when building a fresh Guile to interpret the
+compiler, so we can compile eval.scm. Thereafter all calls to
+primitive-eval are implemented by VM-compiled code.
+
+This allows all of Guile's procedures, be they interpreted or compiled,
+to execute on the same stack, unifying multiple-value return semantics,
+providing for proper tail recursion between interpreted and compiled
+code, and simplifying debugging.
+
+As part of this change, the evaluator no longer mutates the internal
+representation of the code being evaluated in a thread-unsafe manner.
+
+There are two negative aspects of this change, however. First, Guile
+takes a lot longer to compile now. Also, there is less debugging
+information available for debugging interpreted code. We hope to improve
+both of these situations.
+
+There are many changes to the internal C evalator interface, but all
+public interfaces should be the same. See the ChangeLog for details. If
+we have inadvertantly changed an interface that you were using, please
+contact bug-guile@gnu.org.
+
** Procedure removed: `the-environment'
This procedure was part of the interpreter's execution model, and does
not apply to the compiler.
-** Files loaded with `primitive-load-path' will now be compiled
- automatically.
+** No more `local-eval'
+
+`local-eval' used to exist so that one could evaluate code in the
+lexical context of a function. Since there is no way to get the lexical
+environment any more, as that concept has no meaning for the compiler,
+and a different meaning for the interpreter, we have removed the
+function.
+
+If you think you need `local-eval', you should probably implement your
+own metacircular evaluator. It will probably be as fast as Guile's
+anyway.
+
+** Scheme source files will now be compiled automatically.
If a compiled .go file corresponding to a .scm file is not found or is
not fresh, the .scm file will be compiled on the fly, and the resulting
.go file stored away. An advisory note will be printed on the console.
-Note that this mechanism depends on preservation of the .scm and .go
-modification times; if the .scm or .go files are moved after
-installation, care should be taken to preserve their original
+Note that this mechanism depends on the timestamp of the .go file being
+newer than that of the .scm file; if the .scm or .go files are moved
+after installation, care should be taken to preserve their original
timestamps.
Autocompiled files will be stored in the $XDG_CACHE_HOME/guile/ccache
To inhibit autocompilation, set the GUILE_AUTO_COMPILE environment
variable to 0, or pass --no-autocompile on the Guile command line.
-Note that there is currently a bug here: automatic compilation will
-sometimes be attempted when it shouldn't.
-
-For example, the old (lang elisp) modules are meant to be interpreted,
-not compiled. This bug will be fixed before 2.0. FIXME 2.0: Should say
-something here about module-transformer called for compile.
-
-** Files loaded with `load' will now be compiled automatically.
-
-As with files loaded via `primitive-load-path', `load' will also compile
-its target if autocompilation is enabled, and a fresh compiled file is
-not found.
-
-There are two points of difference to note, however. First, `load' does
-not search `GUILE_LOAD_COMPILED_PATH' for the file; it only looks in the
-autocompilation directory, normally a subdirectory of ~/.cache/guile.
-
-Secondly, autocompilation also applies to files loaded via the -l
-command-line argument -- so the user may experience a slight slowdown
-the first time they run a Guile script, as the script is autocompiled.
-
** New POSIX procedures: `getrlimit' and `setrlimit'
Note however that the interface of these functions is likely to change
in the next prerelease.
-** New procedure in `(oops goops)': `method-formals'
+** New POSIX procedure: `getsid'
+
+Scheme binding for the `getsid' C library call.
-** BUG: (procedure-property func 'arity) does not work on compiled
- procedures
+** New POSIX procedure: `getaddrinfo'
-This will be fixed one way or another before 2.0.
+Scheme binding for the `getaddrinfo' C library function.
+
+** New procedure in `(oops goops)': `method-formals'
** New procedures in (ice-9 session): `add-value-help-handler!',
`remove-value-help-handler!', `add-name-help-handler!'
- `remove-name-help-handler!', `procedure-arguments',
+ `remove-name-help-handler!', `procedure-arguments'
The value and name help handlers provide some minimal extensibility to
the help interface. Guile-lib's `(texinfo reflection)' uses them, for
Additionally, `module-commentary' is now publically exported from
`(ice-9 session).
-** Deprecated: `procedure->memoizing-macro', `procedure->syntax'
+** Removed: `procedure->memoizing-macro', `procedure->syntax'
-These procedures will not work with syncase expansion, and indeed are
-not used in the normal course of Guile. They are still used by the old
-Emacs Lisp support, however.
+These procedures created primitive fexprs for the old evaluator, and are
+no longer supported. If you feel that you need these functions, you
+probably need to write your own metacircular evaluator (which will
+probably be as fast as Guile's, anyway).
** New language: ECMAScript
http://en.wikipedia.org/wiki/Brainfuck for more information about the
Brainfuck language itself.
-** Defmacros may now have docstrings.
+** New language: Elisp
-Indeed, any macro may have a docstring. `object-documentation' from
-`(ice-9 documentation)' may be used to retrieve the docstring, once you
-have a macro value -- but see the above note about first-class macros.
-Docstrings are associated with the syntax transformer procedures.
+Guile now has an experimental Emacs Lisp compiler and runtime. You can
+now switch to Elisp at the repl: `,language elisp'. All kudos to Daniel
+Kraft, and all bugs to bug-guile@gnu.org.
+
+** Better documentation infrastructure for macros
+
+It is now possible to introspect on the type of a macro, e.g.
+syntax-rules, identifier-syntax, etc, and extract information about that
+macro, such as the syntax-rules patterns or the defmacro arguments.
+`(texinfo reflection)' takes advantage of this to give better macro
+documentation.
+
+** Support for arbitrary procedure metadata
+
+Building on its support for docstrings, Guile now supports multiple
+docstrings, adding them to the tail of a compiled procedure's
+properties. For example:
+
+ (define (foo)
+ "one"
+ "two"
+ 3)
+ (procedure-properties foo)
+ => ((name . foo) (documentation . "one") (documentation . "two"))
+
+Also, vectors of pairs are now treated as additional metadata entries:
+
+ (define (bar)
+ #((quz . #f) (docstring . "xyzzy"))
+ 3)
+ (procedure-properties bar)
+ => ((name . bar) (quz . #f) (docstring . "xyzzy"))
+
+This allows arbitrary literals to be embedded as metadata in a compiled
+procedure.
** The psyntax expander now knows how to interpret the @ and @@ special
forms.
It used to be you had to export `helper' from `(foo)' as well.
Thankfully, this has been fixed.
-** New function, `procedure-module'
+** Support for version information in Guile's `module' form
+
+Guile modules now have a `#:version' field. See "R6RS Version
+References", "General Information about Modules", "Using Guile Modules",
+and "Creating Guile Modules" in the manual for more information.
+
+** Support for renaming bindings on module export
+
+Wherever Guile accepts a symbol as an argument to specify a binding to
+export, it now also accepts a pair of symbols, indicating that a binding
+should be renamed on export. See "Creating Guile Modules" in the manual
+for more information.
-While useful on its own, `procedure-module' is used by psyntax on syntax
-transformers to determine the module in which to scope introduced
-identifiers.
+** New procedure: `module-export-all!'
+This procedure exports all current and future bindings from a module.
+Use as `(module-export-all! (current-module))'.
+
** `eval-case' has been deprecated, and replaced by `eval-when'.
-The semantics of `eval-when' are easier to understand. It is still
-missing documentation, however.
+The semantics of `eval-when' are easier to understand. See "Eval When"
+in the manual, for more information.
** Guile is now more strict about prohibiting definitions in expression
contexts.
default expander), and may choose to revisit this situation before 2.0
in response to user feedback.
+** Support for `letrec*'
+
+Guile now supports `letrec*', a recursive lexical binding operator in
+which the identifiers are bound in order. See "Local Bindings" in the
+manual, for more details.
+
+** Internal definitions now expand to `letrec*'
+
+Following the R6RS, internal definitions now expand to letrec* instead
+of letrec. The following program is invalid for R5RS, but valid for
+R6RS:
+
+ (define (foo)
+ (define bar 10)
+ (define baz (+ bar 20))
+ baz)
+
+ ;; R5RS and Guile <= 1.8:
+ (foo) => Unbound variable: bar
+ ;; R6RS and Guile >= 2.0:
+ (foo) => 30
+
+This change should not affect correct R5RS programs, or programs written
+in earlier Guile dialects.
+
+** Macro expansion produces structures instead of s-expressions
+
+In the olden days, macroexpanding an s-expression would yield another
+s-expression. Though the lexical variables were renamed, expansions of
+core forms like `if' and `begin' were still non-hygienic, as they relied
+on the toplevel definitions of `if' et al being the conventional ones.
+
+The solution is to expand to structures instead of s-expressions. There
+is an `if' structure, a `begin' structure, a `toplevel-ref' structure,
+etc. The expander already did this for compilation, producing Tree-IL
+directly; it has been changed now to do so when expanding for the
+evaluator as well.
+
** Defmacros must now produce valid Scheme expressions.
It used to be that defmacros could unquote in Scheme values, as a way of
docstring of `foo', and the definition of `baz' is still in definition
context.
+** Support for settable identifier syntax
+
+Following the R6RS, "variable transformers" are settable
+identifier-syntax. See "Identifier macros" in the manual, for more
+information.
+
+** syntax-case treats `_' as a placeholder
+
+Following R6RS, a `_' in a syntax-rules or syntax-case pattern matches
+anything, and binds no pattern variables. Unlike the R6RS, Guile also
+permits `_' to be in the literals list for a pattern.
+
** Macros need to be defined before their first use.
It used to be that with lazy memoization, this might work:
(define-macro (double-literal x) (double-helper x))
(double-literal 2) => 4
-See the (currently missing) documentation for eval-when for more
-information.
+See the documentation for eval-when for more information.
-** New variable, %pre-modules-transformer
+** `macroexpand' produces structures, not S-expressions.
-Need to document this one some more.
+Given the need to maintain referential transparency, both lexically and
+modular, the result of expanding Scheme expressions is no longer itself
+an s-expression. If you want a human-readable approximation of the
+result of `macroexpand', call `tree-il->scheme' from `(language
+tree-il)'.
-** Temporarily removed functions: `macroexpand', `macroexpand-1'
+** Removed function: `macroexpand-1'
-`macroexpand' will be added back before 2.0. It is unclear how to
-implement `macroexpand-1' with syntax-case, though PLT Scheme does prove
-that it is possible.
+It is unclear how to implement `macroexpand-1' with syntax-case, though
+PLT Scheme does prove that it is possible.
** New reader macros: #' #` #, #,@
#; comments out an entire expression. See SRFI-62 or the R6RS for more
information.
+** Prompts: Delimited, composable continuations
+
+Guile now has prompts as part of its primitive language. See "Prompts"
+in the manual, for more information.
+
+Expressions entered in at the REPL, or from the command line, are
+surrounded by a prompt with the default prompt tag.
+
** `make-stack' with a tail-called procedural narrowing argument no longer
works (with compiled procedures)
that is active in the current continuation, or narrow to a specific
number of stack frames.
-** backtraces through compiled procedures only show procedures that are
+** Backtraces through compiled procedures only show procedures that are
active in the current continuation
Similarly to the previous issue, backtraces in compiled code may be
differences, however. Please mail bug-guile@gnu.org if you see any
deficiencies with Guile's backtraces.
+** New macro: `current-source-location'
+
+The macro returns the current source location (to be documented).
+
** syntax-rules and syntax-case macros now propagate source information
through to the expanded code
(define f (lambda (a) (lambda (b) (* a b))))
Now a syntax error is signaled, as this syntax is not supported by
-default. If there is sufficient demand, this syntax can be supported
-again by default.
+default. Use the `(ice-9 curried-definitions)' module to get back the
+old behavior.
+
+** New procedure, `define!'
+
+`define!' is a procedure that takes two arguments, a symbol and a value,
+and binds the value to the symbol in the current module. It's useful to
+programmatically make definitions in the current module, and is slightly
+less verbose than `module-define!'.
** All modules have names now
created without a name, the first time `module-name' is called on it, a
fresh name will be lazily generated for it.
+** The module namespace is now separate from the value namespace
+
+It was a little-known implementation detail of Guile's module system
+that it was built on a single hierarchical namespace of values -- that
+if there was a module named `(foo bar)', then in the module named
+`(foo)' there was a binding from `bar' to the `(foo bar)' module.
+
+This was a neat trick, but presented a number of problems. One problem
+was that the bindings in a module were not apparent from the module
+itself; perhaps the `(foo)' module had a private binding for `bar', and
+then an external contributor defined `(foo bar)'. In the end there can
+be only one binding, so one of the two will see the wrong thing, and
+produce an obtuse error of unclear provenance.
+
+Also, the public interface of a module was also bound in the value
+namespace, as `%module-public-interface'. This was a hack from the early
+days of Guile's modules.
+
+Both of these warts have been fixed by the addition of fields in the
+`module' data type. Access to modules and their interfaces from the
+value namespace has been deprecated, and all accessors use the new
+record accessors appropriately.
+
+When Guile is built with support for deprecated code, as is the default,
+the value namespace is still searched for modules and public interfaces,
+and a deprecation warning is raised as appropriate.
+
+Finally, to support lazy loading of modules as one used to be able to do
+with module binder procedures, Guile now has submodule binders, called
+if a given submodule is not found. See boot-9.scm for more information.
+
+** New procedures: module-ref-submodule, module-define-submodule,
+ nested-ref-module, nested-define-module!, local-ref-module,
+ local-define-module
+
+These new accessors are like their bare variants, but operate on
+namespaces instead of values.
+
+** The (app modules) module tree is officially deprecated
+
+It used to be that one could access a module named `(foo bar)' via
+`(nested-ref the-root-module '(app modules foo bar))'. The `(app
+modules)' bit was a never-used and never-documented abstraction, and has
+been deprecated. See the following mail for a full discussion:
+
+ http://lists.gnu.org/archive/html/guile-devel/2010-04/msg00168.html
+
+The `%app' binding is also deprecated.
+
+** `module-filename' field and accessor
+
+Modules now record the file in which they are defined. This field may be
+accessed with the new `module-filename' procedure.
+
+** Modules load within a known environment
+
+It takes a few procedure calls to define a module, and those procedure
+calls need to be in scope. Now we ensure that the current module when
+loading a module is one that has the needed bindings, instead of relying
+on chance.
+
** Many syntax errors have different texts now
Syntax errors still throw to the `syntax-error' key, but the arguments
any of these procedures provided useful facilities to you, we encourage
you to contact the Guile developers.
+** Hygienic macros documented as the primary syntactic extension mechanism.
+
+The macro documentation was finally fleshed out with some documentation
+on `syntax-rules' and `syntax-case' macros, and other parts of the macro
+expansion process. See "Macros" in the manual, for details.
+
** psyntax is now the default expander
Scheme code is now expanded by default by the psyntax hygienic macro
There is no longer any need to import the `(ice-9 syncase)' module
(which is now deprecated). The expander may be invoked directly via
-`sc-expand', though it is normally searched for via the current module
+`macroexpand', though it is normally searched for via the current module
transformer.
Also, the helper routines for syntax-case are available in the default
`bound-identifier=?', `free-identifier=?', `generate-temporaries',
`identifier?', and `syntax-violation'. See the R6RS for documentation.
+** Tail patterns in syntax-case
+
+Guile has pulled in some more recent changes from the psyntax portable
+syntax expander, to implement support for "tail patterns". Such patterns
+are supported by syntax-rules and syntax-case. This allows a syntax-case
+match clause to have ellipses, then a pattern at the end. For example:
+
+ (define-syntax case
+ (syntax-rules (else)
+ ((_ val match-clause ... (else e e* ...))
+ [...])))
+
+Note how there is MATCH-CLAUSE, which is ellipsized, then there is a
+tail pattern for the else clause. Thanks to Andreas Rottmann for the
+patch, and Kent Dybvig for the code.
+
** Lexical bindings introduced by hygienic macros may not be referenced
by nonhygienic macros.
(bind-x 10 (ref x)))
It is not normal to run into this situation with existing code. However,
-as code is ported over from defmacros to syntax-case, it is possible to
-run into situations like this. In the future, Guile will probably port
-its `while' macro to syntax-case, which makes this issue one to know
-about.
+if you have defmacros that expand to hygienic macros, it is possible to
+run into situations like this. For example, if you have a defmacro that
+generates a `while' expression, the `break' bound by the `while' may not
+be visible within other parts of your defmacro. The solution is to port
+from defmacros to syntax-rules or syntax-case.
** Macros may no longer be referenced as first-class values.
/referenced/ via the module system, e.g. `(module-ref (current-module)
'if)'.
-This decision may be revisited before the 2.0 release. Feedback welcome
-to guile-devel@gnu.org (subscription required) or bug-guile@gnu.org (no
-subscription required).
+** Macros may now have docstrings.
+
+`object-documentation' from `(ice-9 documentation)' may be used to
+retrieve the docstring, once you have a macro value -- but see the above
+note about first-class macros. Docstrings are associated with the syntax
+transformer procedures.
** `case-lambda' is now available in the default environment.
`(srfi srfi-16)' module. Use the srfi-16 module explicitly if you wish
to maintain compatibility with Guile 1.8 and earlier.
-** Compiled procedures may now have more than one arity.
+** Procedures may now have more than one arity.
This can be the case, for example, in case-lambda procedures. The
arities of compiled procedures may be accessed via procedures from the
`(system vm program)' module; see "Compiled Procedures", "Optional
Arguments", and "Case-lambda" in the manual.
+** Deprecate arity access via (procedure-properties proc 'arity)
+
+Instead of accessing a procedure's arity as a property, use the new
+`procedure-minimum-arity' function, which gives the most permissive
+arity that the the function has, in the same format as the old arity
+accessor.
+
** `lambda*' and `define*' are now available in the default environment
As with `case-lambda', `(ice-9 optargs)' continues to be supported, for
Optional and keyword arguments now dispatch via special VM operations,
without the need to cons rest arguments, making them very fast.
+** New function, `truncated-print', with `format' support
+
+`(ice-9 pretty-print)' now exports `truncated-print', a printer that
+will ensure that the output stays within a certain width, truncating the
+output in what is hopefully an intelligent manner. See the manual for
+more details.
+
+There is a new `format' specifier, `~@y', for doing a truncated
+print (as opposed to `~y', which does a pretty-print). See the `format'
+documentation for more details.
+
+** Passing a number as the destination of `format' is deprecated
+
+The `format' procedure in `(ice-9 format)' now emits a deprecation
+warning if a number is passed as its first argument.
+
+** SRFI-4 vectors reimplemented in terms of R6RS bytevectors
+
+Guile now implements SRFI-4 vectors using bytevectors. Often when you
+have a numeric vector, you end up wanting to write its bytes somewhere,
+or have access to the underlying bytes, or read in bytes from somewhere
+else. Bytevectors are very good at this sort of thing. But the SRFI-4
+APIs are nicer to use when doing number-crunching, because they are
+addressed by element and not by byte.
+
+So as a compromise, Guile allows all bytevector functions to operate on
+numeric vectors. They address the underlying bytes in the native
+endianness, as one would expect.
+
+Following the same reasoning, that it's just bytes underneath, Guile
+also allows uniform vectors of a given type to be accessed as if they
+were of any type. One can fill a u32vector, and access its elements with
+u8vector-ref. One can use f64vector-ref on bytevectors. It's all the
+same to Guile.
+
+In this way, uniform numeric vectors may be written to and read from
+input/output ports using the procedures that operate on bytevectors.
+
+Calls to SRFI-4 accessors (ref and set functions) from Scheme are now
+inlined to the VM instructions for bytevector access.
+
+See "SRFI-4" in the manual, for more information.
+
+** Nonstandard SRFI-4 procedures now available from `(srfi srfi-4 gnu)'
+
+Guile's `(srfi srfi-4)' now only exports those srfi-4 procedures that
+are part of the standard. Complex uniform vectors and the
+`any->FOOvector' family are now available only from `(srfi srfi-4 gnu)'.
+
+Guile's default environment imports `(srfi srfi-4)', and probably should
+import `(srfi srfi-4 gnu)' as well.
+
+See "SRFI-4 Extensions" in the manual, for more information.
+
** New syntax: include-from-path.
`include-from-path' is like `include', except it looks for its file in
documentation for more information. Thanks to Andre van Tonder for the
implementation.
+** `*unspecified*' is identifier syntax
+
+`*unspecified*' is no longer a variable, so it is optimized properly by
+the compiler, and is not `set!'-able.
+
** Unicode characters
Unicode characters may be entered in octal format via e.g. `#\454', or
of Source Files".
The pre-1.9.3 reader handled 8-bit clean but otherwise unspecified source
-code. This use is now discouraged.
+code. This use is now discouraged. Binary input and output is
+currently supported by opening ports in the ISO-8859-1 locale.
** Support for locale transcoding when reading from and writing to ports
processing. It appeared that full EBCDIC support was never completed
and was unmaintained.
-** Compile-time warnings: -Wunbound-variable, -Warity-mismatch.
+** Compile-time warnings
Guile can warn about potentially unbound free variables. Pass the
-Wunbound-variable on the `guile-tools compile' command line, or add
`#:warnings '(unbound-variable)' to your `compile' or `compile-file'
-invocation.
+invocation. Warnings are also enabled by default for expressions entered
+at the REPL.
Guile can also warn when you pass the wrong number of arguments to a
procedure, with -Warity-mismatch, or `arity-mismatch' in the
`#:warnings' as above.
-** New macro type: syncase-macro
-
-XXX Need to decide whether to document this for 2.0, probably should:
-make-syncase-macro, make-extended-syncase-macro, macro-type,
-syncase-macro-type, syncase-macro-binding
+Other warnings include `-Wunused-variable' and `-Wunused-toplevel', to
+warn about unused local or global (top-level) variables, and `-Wformat',
+to check for various errors related to the `format' procedure.
** A new `memoize-symbol' evaluator trap has been added.
See `cancel-thread', `set-thread-cleanup!', and `thread-cleanup'.
+** New threads are in `(guile-user)' by default, not `(guile)'
+
+It used to be that a new thread entering Guile would do so in the
+`(guile)' module, unless this was the first time Guile was initialized,
+in which case it was `(guile-user)'. This has been fixed to have all
+new threads unknown to Guile default to `(guile-user)'.
+
+** GOOPS dispatch in scheme
+
+As an implementation detail, GOOPS dispatch is no longer implemented by
+special evaluator bytecodes, but rather directly via a Scheme function
+associated with an applicable struct. There is some VM support for the
+underlying primitives, like `class-of'.
+
+This change will in the future allow users to customize generic function
+dispatch without incurring a performance penalty, and allow us to
+implement method combinations.
+
+** Applicable struct support
+
+One may now make structs from Scheme that may be applied as procedures.
+To do so, make a struct whose vtable is `<applicable-struct-vtable>'.
+That struct will be the vtable of your applicable structs; instances of
+that new struct are assumed to have the procedure in their first slot.
+`<applicable-struct-vtable>' is like Common Lisp's
+`funcallable-standard-class'. Likewise there is
+`<applicable-struct-with-setter-vtable>', which looks for the setter in
+the second slot. This needs to be better documented.
+
** GOOPS cleanups.
GOOPS had a number of concepts that were relevant to the days of Tcl,
but not any more: operators and entities, mainly. These objects were
never documented, and it is unlikely that they were ever used. Operators
were a kind of generic specific to the Tcl support. Entities were
-applicable structures, but were unusable; entities will come back in the
-next alpha release, but with a less stupid name.
+replaced by applicable structs, mentioned above.
+
+** New struct slot allocation: "hidden"
+
+A hidden slot is readable and writable, but will not be initialized by a
+call to make-struct. For example in your layout you would say "ph"
+instead of "pw". Hidden slots are useful for adding new slots to a
+vtable without breaking existing invocations to make-struct.
+
+** eqv? not a generic
+
+One used to be able to extend `eqv?' as a primitive-generic, but no
+more. Because `eqv?' is in the expansion of `case' (via `memv'), which
+should be able to compile to static dispatch tables, it doesn't make
+sense to allow extensions that would subvert this optimization.
** `inet-ntop' and `inet-pton' are always available.
there is no more need to use `inet-aton'/`inet-ntoa'. The latter
functions are deprecated.
+** New primitive: `tmpfile'.
+
+See "File System" in the manual.
+
+** Random generator state may be serialized to a datum
+
+`random-state->datum' will serialize a random state to a datum, which
+may be written out, read back in later, and revivified using
+`datum->random-state'. See "Random" in the manual, for more details.
+
+** Fix random number generator on 64-bit platforms
+
+There was a nasty bug on 64-bit platforms in which asking for a random
+integer with a range between 2**32 and 2**64 caused a segfault. After
+many embarrassing iterations, this was fixed.
+
** Fast bit operations.
The bit-twiddling operations `ash', `logand', `logior', and `logxor' now
have dedicated bytecodes. Guile is not just for symbolic computation,
it's for number crunching too.
+** Faster SRFI-9 record access
+
+SRFI-9 records are now implemented directly on top of Guile's structs,
+and their accessors are defined in such a way that normal call-sites
+inline to special VM opcodes, while still allowing for the general case
+(e.g. passing a record accessor to `apply').
+
** R6RS block comment support
Guile now supports R6RS nested block comments. The start of a comment is
;; separate compilation phase.
(fluid-set! current-reader my-reader)))
-** Fix bad interaction between `false-if-exception' and stack-call.
-
-Exceptions thrown by `false-if-exception' were erronously causing the
-stack to be saved, causing later errors to show the incorrectly-saved
-backtrace. This has been fixed.
-
** New global variables: %load-compiled-path, %load-compiled-extensions
These are analogous to %load-path and %load-extensions.
+** New fluid: `%file-port-name-canonicalization'
+
+This fluid parameterizes the file names that are associated with file
+ports. If %file-port-name-canonicalization is 'absolute, then file names
+are canonicalized to be absolute paths. If it is 'relative, then the
+name is canonicalized, but any prefix corresponding to a member of
+`%load-path' is stripped off. Otherwise the names are passed through
+unchanged.
+
+In addition, the `compile-file' and `compile-and-load' procedures bind
+%file-port-name-canonicalization to their `#:canonicalization' keyword
+argument, which defaults to 'relative. In this way, one might compile
+"../module/ice-9/boot-9.scm", but the path that gets residualized into
+the .go is "ice-9/boot-9.scm".
+
** New procedure, `make-promise'
`(make-promise (lambda () foo))' is equivalent to `(delay foo)'.
Instead, use make-typed-array, list->typed-array, or array-type,
respectively.
+** Deprecate the old `scm-style-repl'
+
+The following bindings from boot-9 are now found in `(ice-9
+scm-style-repl)': `scm-style-repl', `error-catching-loop',
+`error-catching-repl', `bad-throw', `scm-repl-silent'
+`assert-repl-silence', `repl-print-unspecified',
+`assert-repl-print-unspecified', `scm-repl-verbose',
+`assert-repl-verbosity', `scm-repl-prompt', `set-repl-prompt!', `repl',
+`default-pre-unwind-handler', `handle-system-error',
+
+The following bindings have been deprecated, with no replacement:
+`pre-unwind-handler-dispatch'.
+
+The following bindings have been totally removed:
+`before-signal-stack'.
+
+Deprecated forwarding shims have been installed so that users that
+expect these bindings in the main namespace will still work, but receive
+a deprecation warning.
+
+** `set-batch-mode?!' replaced by `ensure-batch-mode!'
+
+"Batch mode" is a flag used to tell a program that it is not running
+interactively. One usually turns it on after a fork. It may not be
+turned off. `ensure-batch-mode!' deprecates the old `set-batch-mode?!',
+because it is a better interface, as it can only turn on batch mode, not
+turn it off.
+
+** Deprecate `save-stack', `the-last-stack'
+
+It used to be that the way to debug programs in Guile was to capture the
+stack at the time of error, drop back to the REPL, then debug that
+stack. But this approach didn't compose, was tricky to get right in the
+presence of threads, and was not very powerful.
+
+So `save-stack', `stack-saved?', and `the-last-stack' have been moved to
+`(ice-9 save-stack)', with deprecated bindings left in the root module.
+
+** `top-repl' has its own module
+
+The `top-repl' binding, called with Guile is run interactively, is now
+is its own module, `(ice-9 top-repl)'. A deprecated forwarding shim was
+left in the default environment.
+
+** `display-error' takes a frame
+
+The `display-error' / `scm_display_error' helper now takes a frame as an
+argument instead of a stack. Stacks are still supported in deprecated
+builds. Additionally, `display-error' will again source location
+information for the error.
+
+** No more `(ice-9 debug)'
+
+This module had some debugging helpers that are no longer applicable to
+the current debugging model. Importing this module will produce a
+deprecation warning. Users should contact bug-guile for support.
+
+** Remove obsolete debug-options
+
+Removed `breakpoints', `trace', `procnames', `indent', `frames',
+`maxdepth', and `debug' debug-options.
+
+** `backtrace' debug option on by default
+
+Given that Guile 2.0 can always give you a backtrace, backtraces are now
+on by default.
+
+** `turn-on-debugging' deprecated
+
+** Remove obsolete print-options
+
+The `source' and `closure-hook' print options are obsolete, and have
+been removed.
+
+** Remove obsolete read-options
+
+The "elisp-strings" and "elisp-vectors" read options were unused and
+obsolete, so they have been removed.
+
+** Remove eval-options and trap-options
+
+Eval-options and trap-options are obsolete with the new VM and
+evaluator.
+
+** Remove (ice-9 debugger) and (ice-9 debugging)
+
+See "Traps" and "Interactive Debugging" in the manual, for information
+on their replacements.
+
+** Remove the GDS Emacs integration
+
+See "Using Guile in Emacs" in the manual, for info on how we think you
+should use Guile with Emacs.
+
+** Deprecated: `lazy-catch'
+
+`lazy-catch' was a form that captured the stack at the point of a
+`throw', but the dynamic state at the point of the `catch'. It was a bit
+crazy. Please change to use `catch', possibly with a throw-handler, or
+`with-throw-handler'.
+
+** Deprecated `@bind' syntax
+
+`@bind' was part of an older implementation of the Emacs Lisp language,
+and is no longer used.
+
+** Miscellaneous other deprecations
+
+`apply-to-args', `has-suffix?', `scheme-file-suffix'
+`get-option', `for-next-option', `display-usage-report',
+`transform-usage-lambda', `collect', `set-batch-mode?!'
+
** Last but not least, the `λ' macro can be used in lieu of `lambda'
* Changes to the C interface
Libgc is a conservative GC, which we hope will make interaction with C
code easier and less error-prone.
+** New procedures: `scm_to_latin1_stringn', `scm_from_latin1_stringn'
+
+Use these procedures when you know you have latin1-encoded or
+ASCII-encoded strings.
+
+** New procedures: `scm_to_stringn', `scm_from_stringn'
+
+Use these procedures if you want to encode or decode from a particular
+locale.
+
+** New type definitions for `scm_t_intptr' and friends.
+
+`SCM_T_UINTPTR_MAX', `SCM_T_INTPTR_MIN', `SCM_T_INTPTR_MAX',
+`SIZEOF_SCM_T_BITS', `scm_t_intptr' and `scm_t_uintptr' are now
+available to C. Have fun!
+
** The GH interface (deprecated in version 1.6, 2001) was removed.
** Internal `scm_i_' functions now have "hidden" linkage with GCC/ELF
** Functions for handling `scm_option' now no longer require an argument
indicating length of the `scm_t_option' array.
-** scm_primitive_load_path has additional argument, exception_on_error
+** Procedures-with-setters are now implemented using applicable structs
+
+From a user's perspective this doesn't mean very much. But if, for some
+odd reason, you used the SCM_PROCEDURE_WITH_SETTER_P, SCM_PROCEDURE, or
+SCM_SETTER macros, know that they're deprecated now. Also, scm_tc7_pws
+is gone.
+
+** Remove old evaluator closures
+
+There used to be ranges of typecodes allocated to interpreted data
+structures, but that it no longer the case, given that interpreted
+procedure are now just regular VM closures. As a result, there is a
+newly free tc3, and a number of removed macros. See the ChangeLog for
+details.
+
+** Primitive procedures are now VM trampoline procedures
+
+It used to be that there were something like 12 different typecodes
+allocated to primitive procedures, each with its own calling convention.
+Now there is only one, the gsubr. This may affect user code if you were
+defining a procedure using scm_c_make_subr rather scm_c_make_gsubr. The
+solution is to switch to use scm_c_make_gsubr. This solution works well
+both with the old 1.8 and and with the current 1.9 branch.
+
+Guile's old evaluator used to have special cases for applying "gsubrs",
+primitive procedures with specified numbers of required, optional, and
+rest arguments. Now, however, Guile represents gsubrs as normal VM
+procedures, with appropriate bytecode to parse out the correct number of
+arguments, including optional and rest arguments, and then with a
+special bytecode to apply the gsubr.
+
+This allows primitive procedures to appear on the VM stack, allowing
+them to be accurately counted in profiles. Also they now have more
+debugging information attached to them -- their number of arguments, for
+example. In addition, the VM can completely inline the application
+mechanics, allowing for faster primitive calls.
+
+However there are some changes on the C level. There is no more
+`scm_tc7_gsubr' or `scm_tcs_subrs' typecode for primitive procedures, as
+they are just VM procedures. Likewise the macros `SCM_GSUBR_TYPE',
+`SCM_GSUBR_MAKTYPE', `SCM_GSUBR_REQ', `SCM_GSUBR_OPT', and
+`SCM_GSUBR_REST' are gone, as are `SCM_SUBR_META_INFO', `SCM_SUBR_PROPS'
+`SCM_SET_SUBR_GENERIC_LOC', and `SCM_SUBR_ARITY_TO_TYPE'.
+
+Perhaps more significantly, `scm_c_make_subr',
+`scm_c_make_subr_with_generic', `scm_c_define_subr', and
+`scm_c_define_subr_with_generic'. They all operated on subr typecodes,
+and there are no more subr typecodes. Use the scm_c_make_gsubr family
+instead.
+
+Normal users of gsubrs should not be affected, though, as the
+scm_c_make_gsubr family still is the correct way to create primitive
+procedures.
+
+** Remove deprecated array C interfaces
+
+Removed the deprecated array functions `scm_i_arrayp',
+`scm_i_array_ndim', `scm_i_array_mem', `scm_i_array_v',
+`scm_i_array_base', `scm_i_array_dims', and the deprecated macros
+`SCM_ARRAYP', `SCM_ARRAY_NDIM', `SCM_ARRAY_CONTP', `SCM_ARRAY_MEM',
+`SCM_ARRAY_V', `SCM_ARRAY_BASE', and `SCM_ARRAY_DIMS'.
+
+** Remove unused snarf macros
+
+`SCM_DEFINE1', `SCM_PRIMITIVE_GENERIC_1', `SCM_PROC1, and `SCM_GPROC1'
+are no more. Use SCM_DEFINE or SCM_PRIMITIVE_GENERIC instead.
+
+** New functions: `scm_call_n', `scm_c_run_hookn'
+
+`scm_call_n' applies to apply a function to an array of arguments.
+`scm_c_run_hookn' runs a hook with an array of arguments.
+
+** Some SMOB types changed to have static typecodes
+
+Fluids, dynamic states, and hash tables used to be SMOB objects, but now
+they have statically allocated tc7 typecodes.
+
+** Preparations for changing SMOB representation
+
+If things go right, we'll be changing the SMOB representation soon. To
+that end, we did a lot of cleanups to calls to e.g. SCM_CELL_WORD_2(x) when
+the code meant SCM_SMOB_DATA_2(x); user code will need similar changes
+in the future. Code accessing SMOBs using SCM_CELL macros was never
+correct, but until now things still worked. Users should be aware of
+such changes.
+
+** Changed invocation mechanics of applicable SMOBs
+
+Guile's old evaluator used to have special cases for applying SMOB
+objects. Now, with the VM, when Guile sees a SMOB, it looks up a VM
+trampoline procedure for it, and use the normal mechanics to apply the
+trampoline. This simplifies procedure application in the normal,
+non-SMOB case.
+
+The upshot is that the mechanics used to apply a SMOB are different from
+1.8. Descriptors no longer have `apply_0', `apply_1', `apply_2', and
+`apply_3' functions, and the macros SCM_SMOB_APPLY_0 and friends are now
+deprecated. Just use the scm_call_0 family of procedures.
+
+** Removed support shlibs for SRFIs 1, 4, 13, 14, and 60
+
+Though these SRFI support libraries did expose API, they encoded a
+strange version string into their library names. That version was never
+programmatically exported, so there was no way people could use the
+libs.
+
+This was a fortunate oversight, as it allows us to remove the need for
+extra, needless shared libraries --- the C support code for SRFIs 4, 13,
+and 14 was already in core --- and allow us to incrementally return the
+SRFI implementation to Scheme.
** New C function: scm_module_public_interface
This procedure corresponds to Scheme's `module-public-interface'.
+** Undeprecate `scm_the_root_module ()'
+
+It's useful to be able to get the root module from C without doing a
+full module lookup.
+
** Inline vector allocation
Instead of having vectors point out into the heap for their data, their
available which should allow for making a bytevector from an existing
memory region.
+** New struct constructors that don't involve making lists
+
+`scm_c_make_struct' and `scm_c_make_structv' are new varargs and array
+constructors, respectively, for structs. You might find them useful.
+
+** Stack refactor
+
+In Guile 1.8, there were debugging frames on the C stack. Now there is
+no more need to explicitly mark the stack in this way, because Guile has
+a VM stack that it knows how to walk, which simplifies the C API
+considerably. See the ChangeLog for details; the relevant interface is
+in libguile/stacks.h. The Scheme API has not been changed significantly.
+
** Removal of Guile's primitive object system.
There were a number of pieces in `objects.[ch]' that tried to be a
part of it. These files were experimental, never compiled, and would be
better implemented in Scheme anyway. In the future, that is.
+** Deprecate trampolines
+
+There used to be C functions `scm_trampoline_0', `scm_trampoline_1', and
+so on. The point was to do some precomputation on the type of the
+procedure, then return a specialized "call" procedure. However this
+optimization wasn't actually an optimization, so it is now deprecated.
+Just use `scm_call_0', etc instead.
+
+** Deprecated `scm_badargsp'
+
+This function is unused in Guile, but was part of its API.
+
** Better support for Lisp `nil'.
The bit representation of `nil' has been tweaked so that it is now very
efficient to check e.g. if a value is equal to Scheme's end-of-list or
Lisp's nil. Additionally there are a heap of new, specific predicates
-like scm_is_null_or_nil. Probably in the future we will #define
-scm_is_null to scm_is_null_or_nil.
+like scm_is_null_or_nil.
+
+** Better integration of Lisp `nil'.
+
+`scm_is_boolean', `scm_is_false', and `scm_is_null' all return true now
+for Lisp's `nil'. This shouldn't affect any Scheme code at this point,
+but when we start to integrate more with Emacs, it is possible that we
+break code that assumes that, for example, `(not x)' implies that `x' is
+`eq?' to `#f'. This is not a common assumption. Refactoring affected
+code to rely on properties instead of identities will improve code
+correctness. See "Nil" in the manual, for more details.
** Support for static allocation of strings, symbols, and subrs.
later (at the discretion of each person that chooses to redistribute
part of Guile).
+** AM_SILENT_RULES
+
+Guile's build is visually quieter, due to the use of Automake 1.11's
+AM_SILENT_RULES. Build as `make V=1' to see all of the output.
+
** GOOPS documentation folded into Guile reference manual
GOOPS, Guile's object system, used to be documented in separate manuals.
If $(libdir) is /usr/lib, for example, Guile will install its .go files
to /usr/lib/guile/1.9/ccache. These files are architecture-specific.
+** Parallel installability fixes
+
+Guile now installs its header files to a effective-version-specific
+directory, and includes the effective version (e.g. 2.0) in the library
+name (e.g. libguile-2.0.so).
+
+This change should be transparent to users, who should detect Guile via
+the guile.m4 macro, or the guile-2.0.pc pkg-config file. It will allow
+parallel installs for multiple versions of Guile development
+environments.
+
** Dynamically loadable extensions may be placed in a Guile-specific path
Before, Guile only searched the system library paths for extensions
(e.g. /usr/lib), which meant that the names of Guile extensions had to
be globally unique. Installing them to a Guile-specific extensions
-directory is cleaner. Use `pkg-config --variable=extensionsdir
+directory is cleaner. Use `pkg-config --variable=extensiondir
guile-2.0' to get the location of the extensions directory.
+** User Scheme code may be placed in a version-specific path
+
+Before, there was only one way to install user Scheme code to a
+version-specific Guile directory: install to Guile's own path,
+e.g. /usr/share/guile/2.0. The site directory,
+e.g. /usr/share/guile/site, was unversioned. This has been changed to
+add a version-specific site directory, e.g. /usr/share/guile/site/2.0,
+searched before the global site directory.
+
** New dependency: libgc
See http://www.hpl.hp.com/personal/Hans_Boehm/gc/, for more information.
See http://www.gnu.org/software/libunistring/, for more information. Our
Unicode support uses routines from libunistring.
+** New dependency: libffi
+
+See http://sourceware.org/libffi/, for more information.
+
\f
Changes in 1.8.8 (since 1.8.7)
HCoop / bpt / guile.git / blobdiff