mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-29 08:20:20 +02:00
Code Activity

Update NEWS for 2.9.5

Browse source 
* NEWS: Update.
This commit is contained in:
Andy Wingo 2019-09-19 15:41:17 +02:00
parent 462782af86
commit 8fd7914f35
1 changed files with 44 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

74
NEWS
View file

@ -6,46 +6,38 @@ Please send Guile bug reports to bug-guile@gnu.org.
Changes in alpha 2.9.4 (since alpha 2.9.3):
Changes in alpha 2.9.5 (since alpha 2.9.4):
* Notable changes
** Improved compilation of many floating-point primitives
** More optimization for unexported definitions at -O3
Heavy floating-point computations that use `sqrt', `abs', `floor`,
`ceiling`, `sin`, `cos`, `tan`, `asin`, `acos`, and `atan` will be
faster, as the compiler can unbox inexact rationals (flonums) in more
cases.
There is a new optimization pass, `seal-private-bindings', which is
enabled at the new optimization level -O3. (Prior to this change, -O3
was the same as -O2.) With this pass, private declarative bindings
aren't available for access from the first-class module reflection API.
This allows for better optimization.
** Improved compilation of internal `define'
** Better optimization for unboxed int/float conversions
Internal definitions -- like the `define' in `(let () (define x 10)
...)` -- are now compiled more optimally, using the algorithm from
Ghuloum and Dybvig's "Fixing Letrec (reloaded)" paper. This change
makes internal `define' just as efficient as `let', `let*', `letrec',
and similar.
This improves optimization for "exact->inexact" and integer operands to
floating-point ops.
** Interleaved internal definitions and expressions allowed
** Define top-level bindings for aux syntax: `else', `=>', `...', `_'
It used to be that internal definitions had to precede all expressions
in their bodies. This restriction has been relaxed. If an expression
precedes an internal definition, it is treated as if it were a
definition of an unreferenced variable. For example, the expression
`(foo)' transforms to the equivalent of `(define _ (begin (foo) #f))',
if it precedes other definitions.
These auxiliary syntax definitions are specified to be defined in the
R6RS and the R7RS. They were previously unbound, even in the R6RS
modules. This change is not anticipated to cause any incompatibility
with existing Guile code, and improves things for R6RS and R7RS users.
This change improves the readability of Guile programs, as it used to be
that program indentation tended to increase needlessly to allow nested
`let' and `letrec' to re-establish definition contexts after initial
expressions, for example for type-checks on procedure arguments.
** Conventional gettext alias is now `G_'
** Optimization of top-level bindings within a compilation unit
At optimization level 2 and above, Guile's compiler is now allowed to
inline top-level definitions within a compilation unit. See
"Declarative Modules" in the manual, for full details. This change can
improve the performance of programs with many small top-level
definitions by quite a bit!
Related to the last point, since the "Fix literal matching for
module-bound literals" change in the 2.2 series, it was no longer
possible to use the conventional `_' binding as an alias for `gettext',
because a local `_' definition would prevent `_' from being recognized
as aux syntax for `match', `syntax-rules', and similar. The new
recommended conventional alias for `gettext' is `G_'.
@ -82,6 +74,28 @@ Guile 2.2, which can lead to slowdowns when the function is interpreted.
We hope that JIT compilation more than makes up for this slight
slowdown.
** Interleaved internal definitions and expressions allowed
It used to be that internal definitions had to precede all expressions
in their bodies. This restriction has been relaxed. If an expression
precedes an internal definition, it is treated as if it were a
definition of an unreferenced variable. For example, the expression
`(foo)' transforms to the equivalent of `(define _ (begin (foo) #f))',
if it precedes other definitions.
This change improves the readability of Guile programs, as it used to be
that program indentation tended to increase needlessly to allow nested
`let' and `letrec' to re-establish definition contexts after initial
expressions, for example for type-checks on procedure arguments.
** Optimization of top-level bindings within a compilation unit
At optimization level 2 and above, Guile's compiler is now allowed to
inline top-level definitions within a compilation unit. See
"Declarative Modules" in the manual, for full details. This change can
improve the performance of programs with many small top-level
definitions by quite a bit!
** By default, GOOPS classes are not redefinable
It used to be that all GOOPS classes were redefinable, at least in