[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Guile-commits] GNU Guile branch, master, updated. release_1-9-4-140-g6c

From: Andy Wingo
Subject: [Guile-commits] GNU Guile branch, master, updated. release_1-9-4-140-g6cf4304
Date: Tue, 17 Nov 2009 20:51:09 +0000

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Guile".

The branch, master has been updated
       via  6cf430473a3e9698a57649c9bd3f682f05f9e809 (commit)
      from  ff74e44ecba55f50b2c2c84bad2f13bed9489455 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 6cf430473a3e9698a57649c9bd3f682f05f9e809
Author: Andy Wingo <address@hidden>
Date:   Tue Nov 17 21:51:56 2009 +0100

    Update NEWS.
    * NEWS: Update for 1.9.5. Still needs these entries to be folded into
      the main section though.


Summary of changes:
 NEWS |  167 ++++++++++++++++++++++++++++++++++++++++++++++++++----------------
 1 files changed, 127 insertions(+), 40 deletions(-)

diff --git a/NEWS b/NEWS
index a9a7adf..75d1987 100644
--- a/NEWS
+++ b/NEWS
@@ -8,63 +8,146 @@ Please send Guile bug reports to address@hidden
 (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
-** `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
+** `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'
+** 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.
+** 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.
-** Wide character/string support in locale-specific character/string
-   functions
+** Inline vector allocation
-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
+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
+** 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 
 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'
+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:

GNU Guile

reply via email to

[Prev in Thread] Current Thread [Next in Thread]