[Top][All Lists]

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

GNU Guile 2.1.7 released (beta)

From: Andy Wingo
Subject: GNU Guile 2.1.7 released (beta)
Date: Sat, 18 Feb 2017 11:31:20 +0100
User-agent: Gnus/5.13 (Gnus v5.13) Emacs/25.1 (gnu/linux)

We are pleased to announce GNU Guile release 2.1.7.

Guile 2.1.7 is the seventh pre-release in what will eventually become
the 2.2 release series.  We encourage you to test this release and
provide feedback to address@hidden

This is a bug-fix release, mostly fixing bugs related to suspending
partial continuations on one thread and resuming them on another.  See
the full NEWS below for details.

At this point you might ask yourself when 2.2.0 is coming.  The answer
is, very soon!  A followup mail will propose a timeline and a list of
blocker bugs.  I would like to aim for final prerelease in another 4
weeks and a final release a week after that.

                             *  *  *

The Guile web page is located at, 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, with
support for many SRFIs, packaged for use in a wide variety of
environments.  In addition to implementing the R5RS Scheme standard,
Guile includes a module system, full access to POSIX system calls,
networking support, multiple threads, dynamic linking, a foreign
function call interface, and powerful string processing.

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.1.7 can be installed in parallel with Guile 2.0.x; see

A more detailed NEWS summary follows these details on how to get the
Guile sources.

Here are the compressed sources:   (17MB)   (10MB)

Here are the GPG detached signatures[*]:

Use a mirror for higher download bandwidth:

Here are the SHA256 checksums:


[*] 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.1.7.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 --recv-keys 

and rerun the 'gpg --verify' command.

This release was bootstrapped with the following tools:
  Autoconf 2.69
  Automake 1.15
  Libtool 2.4.6
  Gnulib v0.1-1157-gb03f418
  Makeinfo 6.3

                             *  *  *

Changes in 2.1.7 (changes since the 2.1.6 alpha release):

* Notable changes

** Web server now suspendable

The web server's implementation has been slightly modified in order to
allow coroutines to suspend and resume around it when it would block on
input or output.  See "Non-Blocking IO" in the manual for more.

** Add support for arrays in `truncated-print'.

See "Pretty Printing" in the manual.  Thanks to Daniel Llorens.

** Gnulib update

Gnulib has been updated to v0.1-1157-gb03f418.

* Performance improvements

** Stringbufs immutable by default

Stringbufs are backing buffers for strings, and are not user-visible.
Calling "substring" on a base string will result in a new string that
shares state with the base string's stringbuf.  A subsequent attempt to
mutate the substring will first copy a fresh stringbuf; that is, Guile's
strings are copy-on-write.  There is also "substring/shared" which
allows mutations to be shared between substring and base string; in that
case the stringbuf is modified directly.

It used to be that mutating a string would have to take a global lock,
to ensure that no one was concurrently taking a copy-on-write substring
of that string.  That is, stringbufs were mutable by default and
transitioning to immutable could happen at any time.

This situation has been reversed: stringbufs are now immutable by
default and attempts to mutate an immutable stringbuf will copy a fresh
stringbuf and mark it as mutable.  This way we can avoid the global
lock.  This change likely speeds up common "substring" workloads, though
it make make the first in-place mutation on an immutable string take
more time because it has to copy a fresh backing stringbuf.

** Speed up number->string

** `accept' now takes optional flags argument

These flags can include `SOCK_NONBLOCK' and `SOCK_CLOEXEC', indicating
options to apply to the returned socket, potentially removing the need
for additional system calls to set these options.  See "Network Sockets
and Communication" in the manual, for more.

* New deprecations


Instead, use `lseek (fd, 0, SEEK_CUR)' directly.

* Bug fixes

** Fix too-broad capture of dynamic stack by delimited continuations

Guile was using explicit stacks to represent, for example, the chain of
current exception handlers.  This means that a delimited continuation
that captured a "catch" expression would capture the whole stack of
exception handlers, not just the exception handler added by the "catch".
This led to strangeness when resuming the continuation in some other
context like other threads; "throw" could see an invalid stack of
exception handlers.  This has been fixed by the addition of the new
"fluid-ref*" procedure that can access older values of fluids; in this
way the exception handler stack is now implicit.  See "Fluids and
Dynamic States" in the manual, for more on fluid-ref*.

** Fix bug comparing unboxed floating-point values (#25492)

Thanks to Daniel Llorens.

** Fix crasher bugs for multiple threads writing to same port

** Fix bug resuming partial continuations that contain prompts

reply via email to

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