mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-31 09:20:23 +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 * 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`, There is a new optimization pass, `seal-private-bindings', which is
`ceiling`, `sin`, `cos`, `tan`, `asin`, `acos`, and `atan` will be enabled at the new optimization level -O3. (Prior to this change, -O3
faster, as the compiler can unbox inexact rationals (flonums) in more was the same as -O2.) With this pass, private declarative bindings
cases. 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) This improves optimization for "exact->inexact" and integer operands to
...)` -- are now compiled more optimally, using the algorithm from floating-point ops.
Ghuloum and Dybvig's "Fixing Letrec (reloaded)" paper. This change
makes internal `define' just as efficient as `let', `let*', `letrec',
and similar.
** 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 These auxiliary syntax definitions are specified to be defined in the
in their bodies. This restriction has been relaxed. If an expression R6RS and the R7RS. They were previously unbound, even in the R6RS
precedes an internal definition, it is treated as if it were a modules. This change is not anticipated to cause any incompatibility
definition of an unreferenced variable. For example, the expression with existing Guile code, and improves things for R6RS and R7RS users.
`(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 ** Conventional gettext alias is now `G_'
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 Related to the last point, since the "Fix literal matching for
module-bound literals" change in the 2.2 series, it was no longer
At optimization level 2 and above, Guile's compiler is now allowed to possible to use the conventional `_' binding as an alias for `gettext',
inline top-level definitions within a compilation unit. See because a local `_' definition would prevent `_' from being recognized
"Declarative Modules" in the manual, for full details. This change can as aux syntax for `match', `syntax-rules', and similar. The new
improve the performance of programs with many small top-level recommended conventional alias for `gettext' is `G_'.
definitions by quite a bit!
@ -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 We hope that JIT compilation more than makes up for this slight
slowdown. 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 ** By default, GOOPS classes are not redefinable
It used to be that all GOOPS classes were redefinable, at least in It used to be that all GOOPS classes were redefinable, at least in