Re: GNU Guile 2.9.9 Released [beta]
Stefan Israelsson Tampe <[email protected]> Mon, 13 Jan 2020 22:33:16 +0100
| Newsgroups | gmane.lisp.guile.sources,gmane.lisp.guile.user,gmane.lisp.guile.devel |
|---|---|
| Message-ID | <CAGua6m13ECsq2iJosWZxC0sHXcHzd2Bc2CTHGL8rDc5zb3NS+Q@mail.gmail.com> |
--000000000000d37fa3059c0c398a Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable I mean that this bug is for 2.9.9 On Mon, Jan 13, 2020 at 10:32 PM Stefan Israelsson Tampe < [email protected]> wrote: > Nice, but I think we are not there yet. > > In current guile (eq? f f) =3D #f for a procedure f. Try: > > (define-module (b) > #:export (f)) > > (define (g x) x) > (define (u x) g) > (define (f x) > (pk eq? (eq? g (u x))) > (pk eqv? (eqv? g (u x))) > (pk equal? (equal? g (u x))) > (pk (object-address g) (object-address (u x)))) > > scheme@(guile-user)> (use-modules (b)) > ;;; note: source file /home/stis/b.scm > ;;; newer than compiled > /home/stis/.cache/guile/ccache/3.0-LE-8-4.2/home/stis/ > b.scm.go > ;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=3D0 > ;;; or pass the --no-auto-compile argument to disable. > ;;; compiling /home/stis/b.scm > ;;; compiled > /home/stis/.cache/guile/ccache/3.0-LE-8-4.2/home/stis/b.scm.go > scheme@(guile-user)> (f 1) > > ;;; (#<procedure eq? (#:optional _ _ . _)> #f) > > ;;; (#<procedure eqv? (#:optional _ _ . _)> #f) > > ;;; (#<procedure equal? (#:optional _ _ . _)> #f) > > ;;; (139824931374184 139824931374200) > > > On Mon, Jan 13, 2020 at 9:39 AM Andy Wingo <[email protected]> wrote: > >> We are pleased to announce GNU Guile release 2.9.9. This is the ninfth >> and probably final pre-release of what will eventually become the 3.0 >> release series. >> >> Compared to the current stable series (2.2.x), the future Guile 3.0 adds >> support for just-in-time native code generation, speeding up all Guile >> programs. See the NEWS extract at the end of the mail for full details. >> >> Compared to the previous prerelease (2.9.7), Guile 2.9.8 fixes a number >> of bugs. >> >> The current plan is to make a 3.0.0 final release on 17 January 2020. >> If there's nothing wrong with this prerelease, 3.0.0 will be essentially >> identical to 2.9.9. With that in mind, please test and make sure the >> release works on your platform! Please send any build reports (success >> or failure) to [email protected], along with platform details. You >> can file a bug by sending mail to [email protected]. >> >> The Guile web page is located at http://gnu.org/software/guile/, and >> among other things, it contains a copy of the Guile manual and pointers >> to more resources. >> >> Guile is an implementation of the Scheme programming language, packaged >> for use in a wide variety of environments. In addition to implementing >> the R5RS, R6RS, and R7RS Scheme standards, Guile includes a module >> system, full access to POSIX system calls, networking support, multiple >> threads, dynamic linking, a foreign function call interface, powerful >> string processing, and HTTP client and server implementations. >> >> Guile can run interactively, as a script interpreter, and as a Scheme >> compiler to VM bytecode. It is also packaged as a library so that >> applications can easily incorporate a complete Scheme interpreter/VM. >> An application can use Guile as an extension language, a clean and >> powerful configuration language, or as multi-purpose "glue" to connect >> primitives provided by the application. It is easy to call Scheme code >> From C code and vice versa. Applications can add new functions, data >> types, control structures, and even syntax to Guile, to create a >> domain-specific language tailored to the task at hand. >> >> Guile 2.9.9 can be installed in parallel with Guile 2.2.x; see >> >> http://www.gnu.org/software/guile/manual/html_node/Parallel-Installation= s.html >> . >> >> A more detailed NEWS summary follows these details on how to get the >> Guile sources. >> >> Here are the compressed sources: >> http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.lz (10MB) >> http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.xz (12MB) >> http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.gz (21MB) >> >> Here are the GPG detached signatures[*]: >> http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.lz.sig >> http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.xz.sig >> http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.gz.sig >> >> Use a mirror for higher download bandwidth: >> http://www.gnu.org/order/ftp.html >> >> Here are the SHA256 checksums: >> >> 59f136e5db36eba070cc5e68784e632dc2beae4b21fd6c7c8ed2c598cc992efc >> guile-2.9.9.tar.lz >> bf71920cfa23e59fc6257bee84ef4dfeccf4f03e96bb8205592e09f9dbff2969 >> guile-2.9.9.tar.xz >> eafe394cf99d9dd1ab837e6d1b9b2b8d9f0cd13bc34e64ca92456ce1bc2b1925 >> guile-2.9.9.tar.gz >> >> [*] Use a .sig file to verify that the corresponding file (without the >> .sig suffix) is intact. First, be sure to download both the .sig file >> and the corresponding tarball. Then, run a command like this: >> >> gpg --verify guile-2.9.9.tar.gz.sig >> >> If that command fails because you don't have the required public key, >> then run this command to import it: >> >> gpg --keyserver keys.gnupg.net --recv-keys >> 4FD4D288D445934E0A14F9A5A8803732E4436885 >> >> and rerun the 'gpg --verify' command. >> >> This release was bootstrapped with the following tools: >> Autoconf 2.69 >> Automake 1.16.1 >> Libtool 2.4.6 >> Gnulib v0.1-1157-gb03f418 >> Makeinfo 6.7 >> >> An extract from NEWS follows. >> >> >> Changes since alpha 2.9.8 (since 2.9.7): >> >> * Notable changes >> >> ** `define-module' #:autoload no longer pulls in the whole module >> >> One of the ways that a module can use another is "autoloads". For >> example: >> >> (define-module (a) #:autoload (b) (make-b)) >> >> In this example, module `(b)' will only be imported when the `make-b' >> identifier is referenced. However besides the imprecision about when a >> given binding is actually referenced, this mechanism used to cause the >> whole imported module to become available, not just the specified >> bindings. This has now been changed to only import the specified >> bindings. >> >> This is a backward-incompatible change. The fix is to mention all >> bindings of interest in the autoload clause. Feedback is welcome. >> >> ** `guard' no longer unwinds the stack for clause tests >> >> SRFI-34, and then R6RS and R7RS, defines a `guard' form that is a >> shorthand for `with-exception-handler'. The cond-like clauses for the >> exception handling are specified to run with the continuation of the >> `guard', while any re-propagation of the exception happens with the >> continuation of the original `raise'. >> >> In practice, this means that one needs full `call-with-continuation' to >> implement the specified semantics, to be able to unwind the stack to the >> cond clauses, then rewind if none match. This is not only quite >> expensive, it is also error-prone as one usually doesn't want to rewind >> dynamic-wind guards in an exceptional situation. Additionally, as >> continuations bind tightly to the current thread, it makes it impossible >> to migrate a subcomputation with a different thread if a `guard' is live >> on the stack, as is done in Fibers. >> >> Guile now works around these issues by running the test portion of the >> guard expressions within the original `raise' continuation, and only >> unwinding once a test matches. This is an incompatible semantic change >> but we think the situation is globally much better, and we expect that >> very few people will be affected by the change. >> >> ** Improve SRFI-43 vector-fill! >> >> SRFI-43 vector-fill! now has the same performance whether an optional >> range is provided or not, and is also provided in core. As a side >> effect, vector-fill! and vector_fill_x no longer work on non-vector >> rank-1 arrays. Such cases were handled incorrectly before; for example, >> prior to this change: >> >> (define a (make-vector 10 'x)) >> (define b (make-shared-array a (lambda (i) (list (* 2 i))) 5)) >> (vector-fill! b 'y) >> >> =3D> #1(y y y x x) >> >> This is now an error. Instead, use array-fill!. >> >> ** Fix compilation on 32-bit targets >> >> A compile error introduced in 2.9.3 prevented compilation on 32-bit >> targets. This has been fixed. >> >> ** Fix a bug in closure conversion >> >> Thanks for Stefan Israelsson Tampe for the report. >> >> ** Fix omission in R7RS support >> >> Somewhat embarrassingly, the R7RS support added earlier in 2.9 failed to >> include an implementation of `define-library'. This oversight has been >> corrected :) >> >> ** Optionally allow duplicate field names in core records >> >> See the new #:allow-duplicate-field-names? keyword argument to >> `make-record-type' in the manual, for more. This restores a needed >> feature to R6RS records. >> >> ** Fix default value of thread-local fluids >> >> Before, `fluid-ref' on an unbound thread-local fluid was returning #f >> instead of the default value of the fluid. Thanks to Rob Browning for >> the fix! >> >> >> >> Changes in alpha 2.9.x (since the stable 2.2 series): >> >> * Notable changes >> >> ** Just-in-time code generation >> >> Guile programs now run up to 4 times faster, relative to Guile 2.2, >> thanks to just-in-time (JIT) native code generation. Notably, this >> brings the performance of "eval" as written in Scheme back to the level >> of "eval" written in C, as in the days of Guile 1.8. >> >> See "Just-In-Time Native Code" in the manual, for more information. JIT >> compilation will be enabled automatically and transparently. To disable >> JIT compilation, configure Guile with `--enable-jit=3Dno' or >> `--disable-jit'. The default is `--enable-jit=3Dauto', which enables th= e >> JIT if it is available. See `./configure --help' for more. >> >> JIT compilation is enabled by default on x86-64, i686, ARMv7, and >> AArch64 targets. >> >> ** Lower-level bytecode >> >> Relative to the virtual machine in Guile 2.2, Guile's VM instruction set >> is now more low-level. This allows it to express more advanced >> optimizations, for example type check elision or integer >> devirtualization, and makes the task of JIT code generation easier. >> >> Note that this change can mean that for a given function, the >> corresponding number of instructions in Guile 3.0 may be higher than >> 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. >> >> ** Record unification >> >> Guile used to have a number of implementations of structured data types >> in the form of "records": a core facility, SRFI-9 (records), SRFI-35 >> (condition types -- a form of records) and R6RS records. These >> facilities were not compatible, as they all were built in different >> ways. This had the unfortunate corollary that SRFI-35 conditions were >> not compatible with R6RS conditions. To fix this problem, we have now >> added the union of functionality from all of these record types into >> core records: single-inheritance subtyping, mutable and immutable >> fields, and so on. See "Records" in the manual, for full details. >> >> R6RS records, SRFI-9 records, and the SRFI-35 and R6RS exception types >> have been accordingly "rebased" on top of core records. >> >> ** Reimplementation of exceptions >> >> Since Guile's origins 25 years ago, `throw' and `catch' have been the >> primary exception-handling primitives. However these primitives have >> two problems. One is that it's hard to handle exceptions in a >> structured way using `catch'. Few people remember what the >> corresponding `key' and `args' are that an exception handler would see >> in response to a call to `error', for example. In practice, this >> results in more generic catch-all exception handling than one might >> like. >> >> The other problem is that `throw', `catch', and especially >> `with-throw-handler' are quite unlike what the rest of the Scheme world >> uses. R6RS and R7RS, for example, have mostly converged on >> SRFI-34-style `with-exception-handler' and `raise' primitives, and >> encourage the use of SRFI-35-style structured exception objects to >> describe the error. Guile's R6RS layer incorporates an adapter between >> `throw'/`catch' and structured exception handling, but it didn't apply >> to SRFI-34/SRFI-35, and we would have to duplicate it for R7RS. >> >> In light of these considerations, Guile has now changed to make >> `with-exception-handler' and `raise-exception' its primitives for >> exception handling and defined a hierarchy of R6RS-style exception types >> in its core. SRFI-34/35, R6RS, and the exception-handling components of >> SRFI-18 (threads) have been re-implemented in terms of this core >> functionality. There is also a a compatibility layer that makes it so >> that exceptions originating in `throw' can be handled by >> `with-exception-hander', and vice-versa for `raise-exception' and >> `catch'. >> >> Generally speaking, users will see no difference. The one significant >> difference is that users of SRFI-34 will see more exceptions flowing >> through their `with-exception-handler'/`guard' forms, because whereas >> before they would only see exceptions thrown by SRFI-34, now they will >> see exceptions thrown by R6RS, R7RS, or indeed `throw'. >> >> Guile's situation is transitional. Most exceptions are still signalled >> via `throw'. These will probably migrate over time to >> `raise-exception', while preserving compatibility of course. >> >> See "Exceptions" in the manual, for full details on the new API. >> >> ** 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! >> >> At optimization level 3 and above, Guile will assume that any top-level >> binding in a declarative compilation unit that isn't exported from a >> module can be completely inlined into its uses. (Prior to this change, >> -O3 was the same as -O2.) Note that with this new >> `seal-private-bindings' pass, private declarative bindings are no longer >> available for access from the first-class module reflection API. The >> optimizations afforded by this pass can be useful when you need a speed >> boost, but having them enabled at optimization level 3 means they are >> not on by default, as they change Guile's behavior in ways that users >> might not expect. >> >> ** By default, GOOPS classes are not redefinable >> >> It used to be that all GOOPS classes were redefinable, at least in >> theory. This facility was supported by an indirection in all "struct" >> instances, even though only a subset of structs would need redefinition. >> We wanted to remove this indirection, in order to speed up Guile >> records, allow immutable Guile records to eventually be described by >> classes, and allow for some optimizations in core GOOPS classes that >> shouldn't be redefined anyway. >> >> Thus in GOOPS now there are classes that are redefinable and classes >> that aren't. By default, classes created with GOOPS are not >> redefinable. To make a class redefinable, it should be an instance of >> `<redefinable-class>'. See "Redefining a Class" in the manual for more >> information. >> >> ** Define top-level bindings for aux syntax: `else', `=3D>', `...', `_' >> >> 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. >> >> ** Conventional gettext alias is now `G_' >> >> 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 auxiliary syntax for `match', `syntax-rules', and similar. The new >> recommended conventional alias for `gettext' is `G_'. >> >> ** Add --r6rs command-line option >> >> The new `install-r6rs!' procedure adapts Guile's defaults to be more >> R6RS-compatible. This procedure is called if the user passes `--r6rs' >> as a command-line argument. See "R6RS Incompatibilities" in the manual, >> for full details. >> >> ** Add support for R7RS >> >> Thanks to G=C3=B6ran Weinholt and OKUMURA Yuki, Guile now implements the= R7RS >> modules. As the R7RS library syntax is a subset of R6RS, to use R7RS >> you just `(import (scheme base))' and off you go. As with R6RS also, >> there are some small lexical incompatibilities regarding hex escapes; >> see "R6RS Support" in the manual, for full details. >> >> Also as with R6RS, there is an `install-r7rs!' procedure and a `--r7rs' >> command-line option. >> >> ** Add #:re-export-and-replace argument to `define-module' >> >> This new keyword specifies a set of bindings to re-export, but also >> marks them as intended to replace core bindings. See "Creating Guile >> Modules" in the manual, for full details. >> >> Note to make this change, we had to change the way replacement flags are >> stored, to being associated with modules instead of individual variable >> objects. This means that users who #:re-export an imported binding that >> was already marked as #:replace by another module will now see warnings, >> as they need to use #:re-export-and-replace instead. >> >> ** `iota' in core and SRFI-1 `iota' are the same >> >> Previously, `iota' in core would not accept start and step arguments and >> would return an empty list for negative count. Now there is only one >> `iota' function with the extended semantics of SRFI-1. Note that as an >> incompatible change, core `iota' no longer accepts a negative count. >> >> * New deprecations >> >> ** scm_t_uint8, etc deprecated in favor of C99 stdint.h >> >> It used to be that Guile defined its own `scm_t_uint8' because C99 >> `uint8_t' wasn't widely enough available. Now Guile finally made the >> change to use C99 types, both internally and in Guile's public headers. >> >> Note that this also applies to SCM_T_UINT8_MAX, SCM_T_INT8_MIN, for intN >> and uintN for N in 8, 16, 32, and 64. Guile also now uses ptrdiff_t >> instead of scm_t_ptrdiff, and similarly for intmax_t, uintmax_t, >> intptr_t, and uintptr_t. >> >> ** The two-argument form of `record-constructor' >> >> Calling `record-constructor' with two arguments (the record type and a >> list of field names) is deprecated. Instead, call with just one >> argument, and provide a wrapper around that constructor if needed. >> >> * Incompatible changes >> >> ** All deprecated code removed >> >> All code deprecated in Guile 2.2 has been removed. See older NEWS, and >> check that your programs can compile without linker warnings and run >> without runtime warnings. See "Deprecation" in the manual. >> >> In particular, the function `scm_generalized_vector_get_handle' which >> was deprecated in 2.0.9 but remained in 2.2, has now finally been >> removed. As a replacement, use `scm_array_get_handle' to get a handle >> and `scm_array_handle_rank' to check the rank. >> >> ** Remove "self" field from vtables and "redefined" field from classes >> >> These fields were used as part of the machinery for class redefinition >> and is no longer needed. >> >> ** VM hook manipulation simplified >> >> The low-level mechanism to instrument a running virtual machine for >> debugging and tracing has been simplified. See "VM Hooks" in the >> manual, for more. >> >> * Changes to the distribution >> >> ** New effective version >> >> The "effective version" of Guile is now 3.0, which allows parallel >> installation with other effective versions (for example, the older Guile >> 2.2). See "Parallel Installations" in the manual for full details. >> Notably, the `pkg-config' file is now `guile-3.0', and there are new >> `guile-3' and `guile-3.0' features for `cond-expand'. >> >> --000000000000d37fa3059c0c398a Content-Type: text/html; charset="UTF-8" Content-Transfer-Encoding: quoted-printable <div dir=3D"ltr">I mean that this bug is for 2.9.9</div><br><div class=3D"g= mail_quote"><div dir=3D"ltr" class=3D"gmail_attr">On Mon, Jan 13, 2020 at 1= 0:32 PM Stefan Israelsson Tampe <<a href=3D"mailto:[email protected]= om">[email protected]</a>> wrote:<br></div><blockquote class=3D"gm= ail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,= 204,204);padding-left:1ex"><div dir=3D"ltr">Nice, but I think we are not th= ere yet.<div><br></div><div>In current guile (eq? f f) =3D #f for a procedu= re f. Try:</div><div><br></div><div>(define-module (b)<br>=C2=A0 #:export (= f))<br><br>(define (g x) x)<br>(define (u x) g)<br>(define (f x)<br>=C2=A0 = (pk eq? =C2=A0 =C2=A0(eq? =C2=A0g (u x)))<br>=C2=A0 (pk eqv? =C2=A0 (eqv? g= (u x)))<br>=C2=A0 (pk equal? (equal? g (u x)))<br>=C2=A0 (pk (object-addre= ss g) (object-address (u x))))<br></div><div><br></div><div><span style=3D"= font-family:monospace"><span style=3D"color:rgb(0,0,0)">scheme@(guile-user)= > (use-modules (b)) </span><br>;;; note: source file /home/stis/b.scm <br>;;; =C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0newer than compiled /home/stis/= .cache/guile/ccache/3.0-LE-8-4.2/home/stis/<br>b.scm.go <br>;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=3D0 <br>;;; =C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0or pass the --no-auto-compile a= rgument to disable. <br>;;; compiling /home/stis/b.scm <br>;;; compiled /home/stis/.cache/guile/ccache/3.0-LE-8-4.2/home/stis/b.sc= m.go <br>scheme@(guile-user)> (f 1) <br> <br>;;; (#<procedure eq? (#:optional _ _ . _)> #f) <br> <br>;;; (#<procedure eqv? (#:optional _ _ . _)> #f) <br> <br>;;; (#<procedure equal? (#:optional _ _ . _)> #f) <br> <br>;;; (139824931374184 139824931374200)<br></span></div><div><br></div></= div><br><div class=3D"gmail_quote"><div dir=3D"ltr" class=3D"gmail_attr">On= Mon, Jan 13, 2020 at 9:39 AM Andy Wingo <<a href=3D"mailto:wingo@pobox.= com" target=3D"_blank">[email protected]</a>> wrote:<br></div><blockquote = class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px sol= id rgb(204,204,204);padding-left:1ex">We are pleased to announce GNU Guile = release 2.9.9.=C2=A0 This is the ninfth<br> and probably final pre-release of what will eventually become the 3.0<br> release series.<br> <br> Compared to the current stable series (2.2.x), the future Guile 3.0 adds<br= > support for just-in-time native code generation, speeding up all Guile<br> programs.=C2=A0 See the NEWS extract at the end of the mail for full detail= s.<br> <br> Compared to the previous prerelease (2.9.7), Guile 2.9.8 fixes a number<br> of bugs.<br> <br> The current plan is to make a 3.0.0 final release on 17 January 2020.<br> If there's nothing wrong with this prerelease, 3.0.0 will be essentiall= y<br> identical to 2.9.9.=C2=A0 With that in mind, please test and make sure the<= br> release works on your platform!=C2=A0 Please send any build reports (succes= s<br> or failure) to <a href=3D"mailto:[email protected]" target=3D"_blank">gui= [email protected]</a>, along with platform details.=C2=A0 You<br> can file a bug by sending mail to <a href=3D"mailto:[email protected]" targ= et=3D"_blank">[email protected]</a>.<br> <br> The Guile web page is located at <a href=3D"http://gnu.org/software/guile/"= rel=3D"noreferrer" target=3D"_blank">http://gnu.org/software/guile/</a>, a= nd<br> among other things, it contains a copy of the Guile manual and pointers<br> to more resources.<br> <br> Guile is an implementation of the Scheme programming language, packaged<br> for use in a wide variety of environments.=C2=A0 In addition to implementin= g<br> the R5RS, R6RS, and R7RS Scheme standards, Guile includes a module<br> system, full access to POSIX system calls, networking support, multiple<br> threads, dynamic linking, a foreign function call interface, powerful<br> string processing, and HTTP client and server implementations.<br> <br> Guile can run interactively, as a script interpreter, and as a Scheme<br> compiler to VM bytecode.=C2=A0 It is also packaged as a library so that<br> applications can easily incorporate a complete Scheme interpreter/VM.<br> An application can use Guile as an extension language, a clean and<br> powerful configuration language, or as multi-purpose "glue" to co= nnect<br> primitives provided by the application.=C2=A0 It is easy to call Scheme cod= e<br> From C code and vice versa.=C2=A0 Applications can add new functions, data<= br> types, control structures, and even syntax to Guile, to create a<br> domain-specific language tailored to the task at hand.<br> <br> Guile 2.9.9 can be installed in parallel with Guile 2.2.x; see<br> <a href=3D"http://www.gnu.org/software/guile/manual/html_node/Parallel-Inst= allations.html" rel=3D"noreferrer" target=3D"_blank">http://www.gnu.org/sof= tware/guile/manual/html_node/Parallel-Installations.html</a>.<br> <br> A more detailed NEWS summary follows these details on how to get the<br> Guile sources.<br> <br> Here are the compressed sources:<br> =C2=A0 <a href=3D"http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.lz" rel=3D= "noreferrer" target=3D"_blank">http://alpha.gnu.org/gnu/guile/guile-2.9.9.t= ar.lz</a>=C2=A0 =C2=A0(10MB)<br> =C2=A0 <a href=3D"http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.xz" rel=3D= "noreferrer" target=3D"_blank">http://alpha.gnu.org/gnu/guile/guile-2.9.9.t= ar.xz</a>=C2=A0 =C2=A0(12MB)<br> =C2=A0 <a href=3D"http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.gz" rel=3D= "noreferrer" target=3D"_blank">http://alpha.gnu.org/gnu/guile/guile-2.9.9.t= ar.gz</a>=C2=A0 =C2=A0(21MB)<br> <br> Here are the GPG detached signatures[*]:<br> =C2=A0 <a href=3D"http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.lz.sig" re= l=3D"noreferrer" target=3D"_blank">http://alpha.gnu.org/gnu/guile/guile-2.9= .9.tar.lz.sig</a><br> =C2=A0 <a href=3D"http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.xz.sig" re= l=3D"noreferrer" target=3D"_blank">http://alpha.gnu.org/gnu/guile/guile-2.9= .9.tar.xz.sig</a><br> =C2=A0 <a href=3D"http://alpha.gnu.org/gnu/guile/guile-2.9.9.tar.gz.sig" re= l=3D"noreferrer" target=3D"_blank">http://alpha.gnu.org/gnu/guile/guile-2.9= .9.tar.gz.sig</a><br> <br> Use a mirror for higher download bandwidth:<br> =C2=A0 <a href=3D"http://www.gnu.org/order/ftp.html" rel=3D"noreferrer" tar= get=3D"_blank">http://www.gnu.org/order/ftp.html</a><br> <br> Here are the SHA256 checksums:<br> <br> =C2=A0 59f136e5db36eba070cc5e68784e632dc2beae4b21fd6c7c8ed2c598cc992efc=C2= =A0 guile-2.9.9.tar.lz<br> =C2=A0 bf71920cfa23e59fc6257bee84ef4dfeccf4f03e96bb8205592e09f9dbff2969=C2= =A0 guile-2.9.9.tar.xz<br> =C2=A0 eafe394cf99d9dd1ab837e6d1b9b2b8d9f0cd13bc34e64ca92456ce1bc2b1925=C2= =A0 guile-2.9.9.tar.gz<br> <br> [*] Use a .sig file to verify that the corresponding file (without the<br> .sig suffix) is intact.=C2=A0 First, be sure to download both the .sig file= <br> and the corresponding tarball.=C2=A0 Then, run a command like this:<br> <br> =C2=A0 gpg --verify guile-2.9.9.tar.gz.sig<br> <br> If that command fails because you don't have the required public key,<b= r> then run this command to import it:<br> <br> =C2=A0 gpg --keyserver <a href=3D"http://keys.gnupg.net" rel=3D"noreferrer"= target=3D"_blank">keys.gnupg.net</a> --recv-keys 4FD4D288D445934E0A14F9A5A= 8803732E4436885<br> <br> and rerun the 'gpg --verify' command.<br> <br> This release was bootstrapped with the following tools:<br> =C2=A0 Autoconf 2.69<br> =C2=A0 Automake 1.16.1<br> =C2=A0 Libtool 2.4.6<br> =C2=A0 Gnulib v0.1-1157-gb03f418<br> =C2=A0 Makeinfo 6.7<br> <br> An extract from NEWS follows.<br> <br> <br> Changes since alpha 2.9.8 (since 2.9.7):<br> <br> * Notable changes<br> <br> ** `define-module' #:autoload no longer pulls in the whole module<br> <br> One of the ways that a module can use another is "autoloads".=C2= =A0 For<br> example:<br> <br> =C2=A0 (define-module (a) #:autoload (b) (make-b))<br> <br> In this example, module `(b)' will only be imported when the `make-b= 9;<br> identifier is referenced.=C2=A0 However besides the imprecision about when = a<br> given binding is actually referenced, this mechanism used to cause the<br> whole imported module to become available, not just the specified<br> bindings.=C2=A0 This has now been changed to only import the specified bind= ings.<br> <br> This is a backward-incompatible change.=C2=A0 The fix is to mention all<br> bindings of interest in the autoload clause.=C2=A0 Feedback is welcome.<br> <br> ** `guard' no longer unwinds the stack for clause tests<br> <br> SRFI-34, and then R6RS and R7RS, defines a `guard' form that is a<br> shorthand for `with-exception-handler'.=C2=A0 The cond-like clauses for= the<br> exception handling are specified to run with the continuation of the<br> `guard', while any re-propagation of the exception happens with the<br> continuation of the original `raise'.<br> <br> In practice, this means that one needs full `call-with-continuation' to= <br> implement the specified semantics, to be able to unwind the stack to the<br= > cond clauses, then rewind if none match.=C2=A0 This is not only quite<br> expensive, it is also error-prone as one usually doesn't want to rewind= <br> dynamic-wind guards in an exceptional situation.=C2=A0 Additionally, as<br> continuations bind tightly to the current thread, it makes it impossible<br= > to migrate a subcomputation with a different thread if a `guard' is liv= e<br> on the stack, as is done in Fibers.<br> <br> Guile now works around these issues by running the test portion of the<br> guard expressions within the original `raise' continuation, and only<br= > unwinding once a test matches.=C2=A0 This is an incompatible semantic chang= e<br> but we think the situation is globally much better, and we expect that<br> very few people will be affected by the change.<br> <br> ** Improve SRFI-43 vector-fill!<br> <br> SRFI-43 vector-fill! now has the same performance whether an optional<br> range is provided or not, and is also provided in core.=C2=A0 As a side<br> effect, vector-fill! and vector_fill_x no longer work on non-vector<br> rank-1 arrays.=C2=A0 Such cases were handled incorrectly before; for exampl= e,<br> prior to this change:<br> <br> =C2=A0 (define a (make-vector 10 'x))<br> =C2=A0 (define b (make-shared-array a (lambda (i) (list (* 2 i))) 5))<br> =C2=A0 (vector-fill! b 'y)<br> <br> =C2=A0 =3D> #1(y y y x x)<br> <br> This is now an error.=C2=A0 Instead, use array-fill!.<br> <br> ** Fix compilation on 32-bit targets<br> <br> A compile error introduced in 2.9.3 prevented compilation on 32-bit<br> targets.=C2=A0 This has been fixed.<br> <br> ** Fix a bug in closure conversion<br> <br> Thanks for Stefan Israelsson Tampe for the report.<br> <br> ** Fix omission in R7RS support<br> <br> Somewhat embarrassingly, the R7RS support added earlier in 2.9 failed to<br= > include an implementation of `define-library'.=C2=A0 This oversight has= been<br> corrected :)<br> <br> ** Optionally allow duplicate field names in core records<br> <br> See the new #:allow-duplicate-field-names? keyword argument to<br> `make-record-type' in the manual, for more.=C2=A0 This restores a neede= d<br> feature to R6RS records.<br> <br> ** Fix default value of thread-local fluids<br> <br> Before, `fluid-ref' on an unbound thread-local fluid was returning #f<b= r> instead of the default value of the fluid.=C2=A0 Thanks to Rob Browning for= <br> the fix!<br> <br> <br> <br> Changes in alpha 2.9.x (since the stable 2.2 series):<br> <br> * Notable changes<br> <br> ** Just-in-time code generation<br> <br> Guile programs now run up to 4 times faster, relative to Guile 2.2,<br> thanks to just-in-time (JIT) native code generation.=C2=A0 Notably, this<br= > brings the performance of "eval" as written in Scheme back to the= level<br> of "eval" written in C, as in the days of Guile 1.8.<br> <br> See "Just-In-Time Native Code" in the manual, for more informatio= n.=C2=A0 JIT<br> compilation will be enabled automatically and transparently.=C2=A0 To disab= le<br> JIT compilation, configure Guile with `--enable-jit=3Dno' or<br> `--disable-jit'.=C2=A0 The default is `--enable-jit=3Dauto', which = enables the<br> JIT if it is available.=C2=A0 See `./configure --help' for more.<br> <br> JIT compilation is enabled by default on x86-64, i686, ARMv7, and<br> AArch64 targets.<br> <br> ** Lower-level bytecode<br> <br> Relative to the virtual machine in Guile 2.2, Guile's VM instruction se= t<br> is now more low-level.=C2=A0 This allows it to express more advanced<br> optimizations, for example type check elision or integer<br> devirtualization, and makes the task of JIT code generation easier.<br> <br> Note that this change can mean that for a given function, the<br> corresponding number of instructions in Guile 3.0 may be higher than<br> Guile 2.2, which can lead to slowdowns when the function is interpreted.<br= > We hope that JIT compilation more than makes up for this slight<br> slowdown.<br> <br> ** Interleaved internal definitions and expressions allowed<br> <br> It used to be that internal definitions had to precede all expressions<br> in their bodies.=C2=A0 This restriction has been relaxed.=C2=A0 If an expre= ssion<br> precedes an internal definition, it is treated as if it were a<br> definition of an unreferenced variable.=C2=A0 For example, the expression<b= r> `(foo)' transforms to the equivalent of `(define _ (begin (foo) #f))= 9;,<br> if it precedes other definitions.<br> <br> This change improves the readability of Guile programs, as it used to be<br= > that program indentation tended to increase needlessly to allow nested<br> `let' and `letrec' to re-establish definition contexts after initia= l<br> expressions, for example for type-checks on procedure arguments.<br> <br> ** Record unification<br> <br> Guile used to have a number of implementations of structured data types<br> in the form of "records": a core facility, SRFI-9 (records), SRFI= -35<br> (condition types -- a form of records) and R6RS records.=C2=A0 These<br> facilities were not compatible, as they all were built in different<br> ways.=C2=A0 This had the unfortunate corollary that SRFI-35 conditions were= <br> not compatible with R6RS conditions.=C2=A0 To fix this problem, we have now= <br> added the union of functionality from all of these record types into<br> core records: single-inheritance subtyping, mutable and immutable<br> fields, and so on.=C2=A0 See "Records" in the manual, for full de= tails.<br> <br> R6RS records, SRFI-9 records, and the SRFI-35 and R6RS exception types<br> have been accordingly "rebased" on top of core records.<br> <br> ** Reimplementation of exceptions<br> <br> Since Guile's origins 25 years ago, `throw' and `catch' have be= en the<br> primary exception-handling primitives.=C2=A0 However these primitives have<= br> two problems.=C2=A0 One is that it's hard to handle exceptions in a<br> structured way using `catch'.=C2=A0 Few people remember what the<br> corresponding `key' and `args' are that an exception handler would = see<br> in response to a call to `error', for example.=C2=A0 In practice, this<= br> results in more generic catch-all exception handling than one might<br> like.<br> <br> The other problem is that `throw', `catch', and especially<br> `with-throw-handler' are quite unlike what the rest of the Scheme world= <br> uses.=C2=A0 R6RS and R7RS, for example, have mostly converged on<br> SRFI-34-style `with-exception-handler' and `raise' primitives, and<= br> encourage the use of SRFI-35-style structured exception objects to<br> describe the error.=C2=A0 Guile's R6RS layer incorporates an adapter be= tween<br> `throw'/`catch' and structured exception handling, but it didn'= t apply<br> to SRFI-34/SRFI-35, and we would have to duplicate it for R7RS.<br> <br> In light of these considerations, Guile has now changed to make<br> `with-exception-handler' and `raise-exception' its primitives for<b= r> exception handling and defined a hierarchy of R6RS-style exception types<br= > in its core.=C2=A0 SRFI-34/35, R6RS, and the exception-handling components = of<br> SRFI-18 (threads) have been re-implemented in terms of this core<br> functionality.=C2=A0 There is also a a compatibility layer that makes it so= <br> that exceptions originating in `throw' can be handled by<br> `with-exception-hander', and vice-versa for `raise-exception' and<b= r> `catch'.<br> <br> Generally speaking, users will see no difference.=C2=A0 The one significant= <br> difference is that users of SRFI-34 will see more exceptions flowing<br> through their `with-exception-handler'/`guard' forms, because where= as<br> before they would only see exceptions thrown by SRFI-34, now they will<br> see exceptions thrown by R6RS, R7RS, or indeed `throw'.<br> <br> Guile's situation is transitional.=C2=A0 Most exceptions are still sign= alled<br> via `throw'.=C2=A0 These will probably migrate over time to<br> `raise-exception', while preserving compatibility of course.<br> <br> See "Exceptions" in the manual, for full details on the new API.<= br> <br> ** Optimization of top-level bindings within a compilation unit<br> <br> At optimization level 2 and above, Guile's compiler is now allowed to<b= r> inline top-level definitions within a compilation unit.=C2=A0 See<br> "Declarative Modules" in the manual, for full details.=C2=A0 This= change can<br> improve the performance of programs with many small top-level<br> definitions by quite a bit!<br> <br> At optimization level 3 and above, Guile will assume that any top-level<br> binding in a declarative compilation unit that isn't exported from a<br= > module can be completely inlined into its uses.=C2=A0 (Prior to this change= ,<br> -O3 was the same as -O2.)=C2=A0 Note that with this new<br> `seal-private-bindings' pass, private declarative bindings are no longe= r<br> available for access from the first-class module reflection API.=C2=A0 The<= br> optimizations afforded by this pass can be useful when you need a speed<br> boost, but having them enabled at optimization level 3 means they are<br> not on by default, as they change Guile's behavior in ways that users<b= r> might not expect.<br> <br> ** By default, GOOPS classes are not redefinable<br> <br> It used to be that all GOOPS classes were redefinable, at least in<br> theory.=C2=A0 This facility was supported by an indirection in all "st= ruct"<br> instances, even though only a subset of structs would need redefinition.<br= > We wanted to remove this indirection, in order to speed up Guile<br> records, allow immutable Guile records to eventually be described by<br> classes, and allow for some optimizations in core GOOPS classes that<br> shouldn't be redefined anyway.<br> <br> Thus in GOOPS now there are classes that are redefinable and classes<br> that aren't.=C2=A0 By default, classes created with GOOPS are not<br> redefinable.=C2=A0 To make a class redefinable, it should be an instance of= <br> `<redefinable-class>'.=C2=A0 See "Redefining a Class" i= n the manual for more<br> information.<br> <br> ** Define top-level bindings for aux syntax: `else', `=3D>', `..= .', `_'<br> <br> These auxiliary syntax definitions are specified to be defined in the<br> R6RS and the R7RS.=C2=A0 They were previously unbound, even in the R6RS<br> modules.=C2=A0 This change is not anticipated to cause any incompatibility<= br> with existing Guile code, and improves things for R6RS and R7RS users.<br> <br> ** Conventional gettext alias is now `G_'<br> <br> Related to the last point, since the "Fix literal matching for<br> module-bound literals" change in the 2.2 series, it was no longer<br> possible to use the conventional `_' binding as an alias for `gettext&#= 39;,<br> because a local `_' definition would prevent `_' from being recogni= zed<br> as auxiliary syntax for `match', `syntax-rules', and similar.=C2=A0= The new<br> recommended conventional alias for `gettext' is `G_'.<br> <br> ** Add --r6rs command-line option<br> <br> The new `install-r6rs!' procedure adapts Guile's defaults to be mor= e<br> R6RS-compatible.=C2=A0 This procedure is called if the user passes `--r6rs&= #39;<br> as a command-line argument.=C2=A0 See "R6RS Incompatibilities" in= the manual,<br> for full details.<br> <br> ** Add support for R7RS<br> <br> Thanks to G=C3=B6ran Weinholt and OKUMURA Yuki, Guile now implements the R7= RS<br> modules.=C2=A0 As the R7RS library syntax is a subset of R6RS, to use R7RS<= br> you just `(import (scheme base))' and off you go.=C2=A0 As with R6RS al= so,<br> there are some small lexical incompatibilities regarding hex escapes;<br> see "R6RS Support" in the manual, for full details.<br> <br> Also as with R6RS, there is an `install-r7rs!' procedure and a `--r7rs&= #39;<br> command-line option.<br> <br> ** Add #:re-export-and-replace argument to `define-module'<br> <br> This new keyword specifies a set of bindings to re-export, but also<br> marks them as intended to replace core bindings.=C2=A0 See "Creating G= uile<br> Modules" in the manual, for full details.<br> <br> Note to make this change, we had to change the way replacement flags are<br= > stored, to being associated with modules instead of individual variable<br> objects.=C2=A0 This means that users who #:re-export an imported binding th= at<br> was already marked as #:replace by another module will now see warnings,<br= > as they need to use #:re-export-and-replace instead.<br> <br> ** `iota' in core and SRFI-1 `iota' are the same<br> <br> Previously, `iota' in core would not accept start and step arguments an= d<br> would return an empty list for negative count. Now there is only one<br> `iota' function with the extended semantics of SRFI-1.=C2=A0 Note that = as an<br> incompatible change, core `iota' no longer accepts a negative count.<br= > <br> * New deprecations<br> <br> ** scm_t_uint8, etc deprecated in favor of C99 stdint.h<br> <br> It used to be that Guile defined its own `scm_t_uint8' because C99<br> `uint8_t' wasn't widely enough available.=C2=A0 Now Guile finally m= ade the<br> change to use C99 types, both internally and in Guile's public headers.= <br> <br> Note that this also applies to SCM_T_UINT8_MAX, SCM_T_INT8_MIN, for intN<br= > and uintN for N in 8, 16, 32, and 64.=C2=A0 Guile also now uses ptrdiff_t<b= r> instead of scm_t_ptrdiff, and similarly for intmax_t, uintmax_t,<br> intptr_t, and uintptr_t.<br> <br> ** The two-argument form of `record-constructor'<br> <br> Calling `record-constructor' with two arguments (the record type and a<= br> list of field names) is deprecated.=C2=A0 Instead, call with just one<br> argument, and provide a wrapper around that constructor if needed.<br> <br> * Incompatible changes<br> <br> ** All deprecated code removed<br> <br> All code deprecated in Guile 2.2 has been removed.=C2=A0 See older NEWS, an= d<br> check that your programs can compile without linker warnings and run<br> without runtime warnings.=C2=A0 See "Deprecation" in the manual.<= br> <br> In particular, the function `scm_generalized_vector_get_handle' which<b= r> was deprecated in 2.0.9 but remained in 2.2, has now finally been<br> removed. As a replacement, use `scm_array_get_handle' to get a handle<b= r> and `scm_array_handle_rank' to check the rank.<br> <br> ** Remove "self" field from vtables and "redefined" fie= ld from classes<br> <br> These fields were used as part of the machinery for class redefinition<br> and is no longer needed.<br> <br> ** VM hook manipulation simplified<br> <br> The low-level mechanism to instrument a running virtual machine for<br> debugging and tracing has been simplified.=C2=A0 See "VM Hooks" i= n the<br> manual, for more.<br> <br> * Changes to the distribution<br> <br> ** New effective version<br> <br> The "effective version" of Guile is now 3.0, which allows paralle= l<br> installation with other effective versions (for example, the older Guile<br= > 2.2).=C2=A0 See "Parallel Installations" in the manual for full d= etails.<br> Notably, the `pkg-config' file is now `guile-3.0', and there are ne= w<br> `guile-3' and `guile-3.0' features for `cond-expand'.<br> <br> </blockquote></div> </blockquote></div> --000000000000d37fa3059c0c398a--