(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.9 (since the 1.9.8 prerelease):
+Changes in 1.9.12 (since the 1.9.11 prerelease):
+
+** Random generator state has an external form
+
+Now the random number generator state can be obtained in external
+(i.e. `read'/`write'-able) form via the new procedure
+`random-state->external'. An externalized state can be reinstantiated by
+calling `external->random-state'.
+
+
+Changes in 1.9.11 (since the 1.9.10 prerelease):
+
+** Renamed module: (rnrs bytevectors)
+
+This module was called (rnrs bytevector), its name from earlier drafts
+of the R6RS. Its name has been changed. Users of previous 1.9 preleases
+may want to search for any stale rnrs/bytevector .go or .scm file, and
+delete them.
+
+** New module: (sxml match)
+
+Guile has incorporated Jim Bender's `sxml-match' library. See
+"sxml-match' in the manual for more information. Thanks, Jim!
+
+** New module: (srfi srfi-9 gnu)
+
+This module adds an extension to srfi-9, `set-record-type-printer!'. See
+"SRFI-9" in the manual for more information.
+
+** 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.
+
+** 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.
+
+The real truth is somewhat more involved: Tree-IL doesn't exist until
+modules have been booted, but we need the expander to boot modules, and
+additionally we need a boot expander before psyntax is loaded. So a
+subset of Tree-IL is defined in C, and the boot expander produces these
+"macroexpanded" structures. Psyntax has been modified to produce those
+structures as well. When Tree-IL loads, it incorporates those structures
+directly as part of its language.
+
+Finally, the evaluator has been adapted to accept these "expanded"
+structures, and enhanced to better support the gamut of this subset of
+Tree-IL, including `lambda*' and `case-lambda'. This was a much-needed
+harmonization between the compiler, expander, and evaluator.
+
+** Deprecated `scm_badargsp'
+
+This function is unused in Guile, but was part of its API.
+
+** `sxml->xml' enhancement
+
+`sxml->xml' from `(sxml simple)' can now handle the result of
+`xml->sxml'. See bug #29260 for more information.
+
+** New module: (system vm coverage)
+
+This new module can produce code coverage reports for compiled Scheme
+code on a line-by-line level. See "Code Coverage" in the manual for more
+information.
+
+** Faster VM hooks.
+
+The frame objects passed to VM hook procedures are now allocated on the
+stack instead of the heap, making the next-instruction hook practical to
+use.
+
+** New `eval-when' situation: `expand'
+
+Sometimes it's important to cause side-effects while expanding an
+expression, even in eval mode. This situation is used in
+`define-module', `use-modules', et al, in order to affect the current
+module and its set of syntax expanders.
+
+** Better module-level hygiene
+
+Instead of attempting to track changes to the current module when
+expanding toplevel sequences, we instead preserve referential
+transparency relative to where the macro itself was defined. If the
+macro should expand to expressions in the context of the new module, it
+should wrap those expressions in `@@', which has been enhanced to accept
+generic expressions, not just identifier references. For example, part
+of the definition of the R6RS `library' form:
+
+ #'(begin
+ (define-module (name name* ...) #:pure #:version (version ...))
+ (import ispec) ...
+ (re-export r ...) (export e ...)
+ (@@ (name name* ...) body)
+ ...)
+
+In this example the `import' refers to the `import' definition in the
+module where the `library' macro is defined, not in the new module.
+
+** Module system macros rewritten as hygienic macros
+
+`define-module', `use-modules', `export', and other such macros have
+been rewritten as hygienic macros. This allows the necessary referential
+transparency for the R6RS `library' form to do the right thing.
+
+** Compiler and VM documentation updated
+
+The documentation for the compiler and VM had slipped out of date; it
+has been brought back... to the future!
+
+** Tree-IL field renaming: `vars' -> `gensyms'
+
+The `vars' fields of <let>, <letrec>, <fix>, and <lambda-case> has been
+renamed to `gensyms', for clarity, and to match <lexical-ref>.
+
+** Removed `version' field from <language>
+
+Language versions weren't being updated or used in any worthwhile way;
+they have been removed, for now at least.
+
+** New procedure: `module-export-all!'
+
+This procedure exports all current and future bindings from a module.
+Use as `(module-export-all! (current-module))'.
+
+** Updates to manual
+
+The introductory sections of the manual have been reorganized
+significantly, making it more accessible to new users of Guile. Check it
+out!
+
+** 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.
+
+** Deprecated `@bind' syntax
+
+`@bind' was part of an older implementation of the Emacs Lisp language,
+and is no longer used.
+
+** 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.
+
+** Source file name canonicalization in `compile-file', `compile-and-load'
+
+These file-compiling procedures now 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".
+
+** 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.
+
+** Remove redundant accessors: program-name, program-documentation,
+ program-properties, program-property
+
+Instead, just use procedure-name, procedure-documentation,
+procedure-properties, and procedure-property.
+
+** Enhance documentation for support of Emacs Lisp's `nil'
+
+See "Nil" in the manual, for more details.
+
+** Enhance documentation for support of other languages
+
+See "Other Languages" in the manual, for more details.
** And of course, the usual collection of bugfixes
** `(srfi srfi-18)', more sophisticated multithreading support
** `(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 (FIXME: undocumented)
+** `(system foreign)', foreign function interface
** Imported statprof, SSAX, and texinfo modules from Guile-Lib
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
** Guile now can compile Scheme to bytecode for a custom virtual machine.
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
The reader supports a new option (changeable via `read-options'),
`square-brackets', which instructs it to interpret square brackets as
-parenthesis. This option is on by default.
+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.
installed. Also it should cut the number of `stat' system calls by half,
in the common case.
+** 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
own metacircular evaluator. It will probably be as fast as Guile's
anyway.
-** Files loaded with `primitive-load-path' will now be compiled
- automatically.
+** 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
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
** New procedure in `(oops goops)': `method-formals'
-** BUG: (procedure-property func 'arity) does not work on compiled
- procedures
-
-This will be fixed one way or another before 2.0.
-
** 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
now switch to Elisp at the repl: `,language elisp'. All kudos to Daniel
Kraft, and all bugs to bug-guile@gnu.org.
-** Defmacros may now have docstrings.
+** 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.
-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.
+** 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.
** `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.
(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
(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!'
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
/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
dispatch without incurring a performance penalty, and allow us to
implement method combinations.
-** 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.
-
** Applicable struct support
One may now make structs from Scheme that may be applied as procedures.
`<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
+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
Instead, use make-typed-array, list->typed-array, or array-type,
respectively.
+** 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'.
+
** Last but not least, the `λ' macro can be used in lieu of `lambda'
* Changes to the C interface
`SCM_DEFINE1', `SCM_PRIMITIVE_GENERIC_1', `SCM_PROC1, and `SCM_GPROC1'
are no more. Use SCM_DEFINE or SCM_PRIMITIVE_GENERIC instead.
-** Add foreign value wrapper
-
-Guile now has a datatype for aliasing "foreign" values, such as native
-long values. This should be useful for making a proper foreign function
-interface. Interested hackers should see libguile/foreign.h.
-
** New functions: `scm_call_n', `scm_c_run_hookn'
`scm_call_n' applies to apply a function to an array of arguments.
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.
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
HCoop / bpt / guile.git / blobdiff