From 6cf430473a3e9698a57649c9bd3f682f05f9e809 Mon Sep 17 00:00:00 2001
From: Andy Wingo <wingo@pobox.com>
Date: Tue, 17 Nov 2009 21:51:56 +0100
Subject: [PATCH] Update NEWS.

* NEWS: Update for 1.9.5. Still needs these entries to be folded into
  the main section though.
---
 NEWS | 167 +++++++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 127 insertions(+), 40 deletions(-)

diff --git a/NEWS b/NEWS
index a9a7adf24..75d198724 100644
--- a/NEWS
+++ b/NEWS
@@ -8,63 +8,146 @@ Please send Guile bug reports to bug-guile@gnu.org.
 (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.4 (since the 1.9.3 prerelease):
+Changes in 1.9.5 (since the 1.9.4 prerelease):
 
-** Guile now adds its install prefix to the LTDL_LIBRARY_PATH
+** Compiled procedures may now have more than one arity.
 
-Users may now install Guile to nonstandard prefixes and just run
-`/path/to/bin/guile', instead of also having to set LTDL_LIBRARY_PATH to
-include `/path/to/lib'.
+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. 
 
-** Dynamically loadable extensions may be placed in a Guile-specific path
+** `case-lambda' is now available in the default environment.
 
-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
-guile-2.0' to get the location of the extensions directory.
+The binding in the default environment is equivalent to the one from the
+`(srfi srfi-16)' module. Use the srfi-16 module explicitly if you wish
+to maintain compatibility with Guile 1.8 and earlier.
 
-** The programmatic `compile' procedure compiles its expression in a
-   fresh module, by default
+** VM calling convention change: callee-parsed arguments
 
-This should make the results of `compile' more predictable. Users may
-specify a specific module in which to compile via the `#:env' keyword
-argument to `compile' (and `compile-file').
+As an internal implementation detail, compiled procedures are now
+responsible for parsing their own arguments, which they receive on the
+stack.
 
-** `compile-file' preserves expansion-time side-effects to `current-reader'
+** VM support for multiple-arity dispatch
 
-User modules may now modify the `current-reader' fluid at expansion
-time, usually within an eval-when, and those modifications will remain
-in place when compiling subsequent forms in the file.
+Calls to procedures with multiple arities, for example those made be
+`case-lambda', now dispatch via special opcodes, without the need to
+cons a rest list.
 
-See "The Scheme Compiler" in the Guile manual for more details.
+** Intermediate language support for multiple-arity procedures.
 
-** Guile's Emacs integration is now more keyboard-friendly
+In the intermediate language, tree-il, all procedures may have one or
+more arities. This allows all Guile languages to have multiple arities.
+It is, however, an incompatible change, and anyone maintaining a
+compiler out-of-tree would be advised to get it into Guile soon :)
 
-Backtraces may now be disclosed with the keyboard in addition to the
-mouse.
+** `lambda*' and `define*' are now available in the default environment
 
-** Compile-time warnings: -Wunbound-variable
+As with `case-lambda', `(ice-9 optargs)' continues to be supported, for
+compatibility purposes. No semantic change has been made (we hope).
+Optional and keyword arguments now dispatch via special VM operations,
+without the need to cons rest arguments, making them very fast.
 
-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.
+** Better support for Lisp `nil'.
 
-** Wide character/string support in locale-specific character/string
-   functions
+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.
 
-The `(ice-9 i18n)' functions (`string-locale<?', etc.) now work
-correctly on wide strings as well. This should finish off the remaining
-Unicode support patches. Please send any Unicode bug reports to
-`bug-guile@gnu.org'.
+** No future.
+
+Actually the future is still in the state that it was, is, and ever
+shall be, Amen, except that `futures.c' and `futures.h' are no longer a
+part of it. These files were experimental, never compiled, and would be
+better implemented in Scheme anyway. In the future, that is.
+
+** Support for static allocation of strings, symbols, and subrs.
+
+Calls to snarfing CPP macros like SCM_DEFINE macro will now allocate
+much of their associated data as static variables, reducing Guile's
+memory footprint.
+
+** Inline vector allocation
+
+Instead of having vectors point out into the heap for their data, their
+data is now allocated inline to the vector object itself. The same is
+true for bytevectors, by default, though there is an indirection
+available which should allow for making a bytevector from an existing
+memory region.
+
+** New syntax: include-from-path.
+
+`include-from-path' is like `include', except it looks for its file in
+the load path. It can be used to compile other files into a file.
+
+** New syntax: quasisyntax.
+
+`quasisyntax' is to `syntax' as `quasiquote' is to `quote'. See the R6RS
+documentation for more information. Thanks to Andre van Tonder for the
+implementation.
+
+** Cleanups to Guile's primitive object system.
+
+There were a number of pieces in `objects.[ch]' that tried to be a
+minimal object system, but were never documented, and were quickly
+obseleted by GOOPS' merge into Guile proper. So `scm_make_class_object',
+`scm_make_subclass_object', `scm_metaclass_standard', and like symbols
+from objects.h are no more. In the very unlikely case in which these
+were useful to you, we urge you to contact guile-devel.
+
+** 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.
+
+** Faster 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.
+
+** `inet-ntop' and `inet-pton' are always available.
+
+Guile now use a portable implementation of `inet_pton'/`inet_ntop', so
+there is no more need to use `inet-aton'/`inet-ntoa'. The latter
+functions are deprecated.
+
+** R6RS block comment support
+
+Guile now supports R6RS nested block comments. The start of a comment is
+marked with `#|', and the end with `|#'.
+
+** `guile-2' cond-expand feature
+
+To test if your code is running under Guile 2.0 (or its alpha releases),
+test for the `guile-2' cond-expand feature. Like this:
+
+     (cond-expand (guile-2 (eval-when (compile)
+                             ;; This must be evaluated at compile time.
+                             (fluid-set! current-reader my-reader)))
+                  (guile
+                           ;; Earlier versions of Guile do not have a
+                           ;; separate compilation phase.
+                           (fluid-set! current-reader my-reader)))
 
 ** ABI harmonization
 
-`scm_primitive_load_path' now has the signature it did in 1.8.
-`scm_array_p' does as well, reverting an incompatible change made in
-1.9.3. Finally, Guile now has the same ABI when built with or without
-threads, something that should make Debian users happy.
+`scm_search_path' now has the signature it did in 1.8, reverting an
+incompatible change made in 1.9.0.
+
+** Compile-time warnings: -Warity-mismatch
+
+Guile can warn when you pass the wrong number of arguments to a
+procedure. Pass the -Warity-mismatch on the `guile-tools compile'
+command line, or add `#:warnings '(arity-mismatch)' to your `compile'
+or `compile-file' invocation.
 
 ** And of course, the usual collection of bugfixes
  
@@ -616,13 +699,17 @@ There was an EBCDIC compile flag that altered some of the character
 processing.  It appeared that full EBCDIC support was never completed
 and was unmaintained.
 
-** Compile-time warnings: -Wunbound-variable
+** Compile-time warnings: -Wunbound-variable, -Warity-mismatch. 
 
 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.
 
+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: