[Guile-commits] 02/02: Update NEWS for 2.9.5

[Andy Wingo]

wingo pushed a commit to branch master
in repository guile.

commit 8fd7914f35b17b14913e962eebe3e6ce90f407c7
Author: Andy Wingo <address@hidden>
Date:   Thu Sep 19 15:41:17 2019 +0200

    Update NEWS for 2.9.5
    
    * NEWS: Update.
---
 NEWS | 74 ++++++++++++++++++++++++++++++++++++++++----------------------------
 1 file changed, 44 insertions(+), 30 deletions(-)

diff --git a/NEWS b/NEWS
index b5b04ff..47654e4 100644
--- a/NEWS
+++ b/NEWS
@@ -6,46 +6,38 @@ Please send Guile bug reports to address@hidden.
 
 
 
-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
-
-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.
+** Define top-level bindings for aux syntax: `else', `=>', `...', `_'
 
-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.
+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.
 
-** Optimization of top-level bindings within a compilation unit
+** Conventional gettext alias is now `G_'
 
-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