[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
GNU Guile 1.9.15 released — last call before 2.0!
From: |
Ludovic Courtès |
Subject: |
GNU Guile 1.9.15 released — last call before 2.0! |
Date: |
Wed, 02 Feb 2011 22:38:56 +0100 |
User-agent: |
Gnus/5.110011 (No Gnus v0.11) Emacs/23.2 (gnu/linux) |
We are pleased to announce GNU Guile release 1.9.15. This is the last
pre-release before the 2.0 release, due on Feb. 16th!
It provides many new noteworthy features, most notably the addition of a
compiler and virtual machine. We encourage you to test them and provide
feedback to address@hidden'.
The Guile web page is located at http://gnu.org/software/guile/, and
among other things, it contains a link to the Guile FAQ and pointers to
the mailing lists.
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 and
a large subset of R6RS, 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.
Here are the compressed sources:
ftp://alpha.gnu.org/gnu/guile/guile-1.9.15.tar.gz (5.3MB)
Here are the GPG detached signatures[*]:
ftp://alpha.gnu.org/gnu/guile/guile-1.9.15.tar.gz.sig
To reduce load on the main server, use a mirror listed at:
http://www.gnu.org/order/ftp.html
Here are the MD5 and SHA1 checksums:
e42ace49a05dcaccb24a264a16646194 guile-1.9.15.tar.gz
0b1cdd5f0506dcda3ed85324b2a0ff510920ee76 guile-1.9.15.tar.gz
[*] You can use either of the above signature files 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-1.9.15.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 EA52ECF4
and rerun the `gpg --verify' command.
This release was bootstrapped with the following tools:
Autoconf 2.68
Automake 1.11.1
Libtool 2.4
Gnulib v0.0-4544-gce083ca
This is a new release series with many new features and differences
compared to 1.8. The complete list of changes compared to the 1.8.x
series is available in the `NEWS' file.
Changes in 1.9.15 (since the 1.9.14 prerelease):
** Formally deprecate omission of port to `format'
It used to be that you could omit passing a port to `format', in some
cases. This still works, but has been formally deprecated.
** ECMAScript fixes
Noah Lavine and Kan-Ru Chen noticed and fixed a number of embarrassing
bugs in object creation, unicode literals in strings, empty function
bodies, non-breaking whitespace, and numeric literals.
** `(web ...)' changes
*** `parse-uri', `unparse-uri' now called `string->uri', `uri->string'
*** `uri-decode' takes `#:encoding' keyword argument, not `#:charset'
*** HTTP header representation change
Guile properly garbage-collects symbols, so there's no need to read some
headers as symbols and some as strings: all header names are symbols
now. The same goes for many key-value constructs in headers. Guile
parses the challenge/authentication headers now, as well. Header decl
objects are no longer exposed to the user.
*** Request and response bodies are always bytevectors
Reading bodies as latin-1 strings was a cute hack, but not general, so
Guile's only official fetch-me-the-body procedures return bytevectors
now.
** New procedures: scm_{to,from}_{utf8,latin1}_symbol{n,}
** New procedures: scm_{to,from}_{utf8,utf32,latin1}_symbol{n,}
These new procedures convert to and from string representations in
particular encodings.
Basically, continue to use locale encoding for user input, user output,
or interacting with the C library. Use latin1 for ASCII, and for
literals in source code. Use utf8 for interaction with modern libraries
which deal in UTF-8. Use utf32 for interaction with utf32-using
libraries. Otherwise use scm_to_stringn or scm_from_stringn with a
specific encoding.
Also, scm_from_latin1_symbol is quite a bit faster now.
** Documentation updates
The GOOPS manual saw a lot of work, as well as documentation for the
`(web ...)' modules.
** Guile uses iconv directly for reading from and writing to ports.
In addition to providing faster Unicode I/O (e.g., `display',
`read-char'), this change improves error reporting.
For instance, the `encoding-error' exception conveys information about
the port and character that could not be encoded. Likewise, the new
`decoding-error' exception conveys information about the port from which
data failed to be decoded, and leaves the port in a known position.
** Source files default to UTF-8.
If source files do not specify their encoding via a `coding:' block,
the default encoding is UTF-8, instead of being taken from the current
locale.
** Man page updates
Thanks to Mark Harig for many suggestions regarding the manual page,
which is getting better.
** Interactive Guile installs the current locale.
Instead of leaving the user in the "C" locale, running the Guile REPL
installs the current locale.
** `recv!', `recvfrom!', `send', `sendto' now deal in bytevectors
These socket procedures now take bytevectors as arguments, instead of
strings. There is some deprecated string support, however.
** New foreign API: `define-wrapped-pointer-type', `pointer?'
See "Foreign Types", for more.
** Changes and bugfixes in numerics code
*** Added two new sets of fast quotient and remainder operators
Added two new sets of fast quotient and remainder operator pairs with
different semantics than the R5RS operators. They support not only
integers, but all reals, including exact rationals and inexact
floating point numbers.
These procedures accept two real numbers N and D, where the divisor D
must be non-zero. `euclidean-quotient' returns the integer Q and
`euclidean-remainder' returns the real R such that N = Q*D + R and
0 <= R < |D|. `euclidean/' returns both Q and R, and is more
efficient than computing each separately. Note that when D > 0,
`euclidean-quotient' returns floor(N/D), and when D < 0 it returns
ceiling(N/D).
`centered-quotient', `centered-remainder', and `centered/' are similar
except that the range of remainders is -abs(D/2) <= R < abs(D/2), and
`centered-quotient' rounds N/D to the nearest integer.
Note that these operators are equivalent to the R6RS integer division
operators `div', `mod', `div-and-mod', `div0', `mod0', and
`div0-and-mod0'.
*** Complex number changes
Guile is now able to represent non-real complex numbers whose
imaginary part is an _inexact_ zero (0.0 or -0.0), per R6RS.
Previously, such numbers were immediately changed into inexact reals.
(real? 0.0+0.0i) now returns #f, per R6RS, although (zero? 0.0+0.0i)
still returns #t, per R6RS. (= 0 0.0+0.0i) and (= 0.0 0.0+0.0i) are
#t, but the same comparisons using `eqv?' or `equal?' are #f.
Like other non-real numbers, these complex numbers with inexact zero
imaginary part will raise exceptions is passed to procedures requiring
reals, such as `<', `>', `<=', `>=', `min', `max', `positive?',
`negative?', `inf?', `nan?', `finite?', etc.
**** `make-rectangular' changes
scm_make_rectangular `make-rectangular' now returns a real number only
if the imaginary part is an _exact_ 0. Previously, it would return a
real number if the imaginary part was an inexact zero.
scm_c_make_rectangular now always returns a non-real complex number,
even if the imaginary part is zero. Previously, it would return a
real number if the imaginary part was zero.
**** `make-polar' changes
scm_make_polar `make-polar' now returns a real number only if the
angle or magnitude is an _exact_ 0. If the magnitude is an exact 0,
it now returns an exact 0. Previously, it would return a real
number if the imaginary part was an inexact zero.
scm_c_make_polar now always returns a non-real complex number, even if
the imaginary part is 0.0. Previously, it would return a real number
if the imaginary part was 0.0.
**** `imag-part' changes
scm_imag_part `imag-part' now returns an exact 0 if applied to an
inexact real number. Previously it returned an inexact zero in this
case.
*** `eqv?' and `equal?' now compare numbers equivalently
scm_equal_p `equal?' now behaves equivalently to scm_eqv_p `eqv?' for
numeric values, per R5RS. Previously, equal? worked differently,
e.g. `(equal? 0.0 -0.0)' returned #t but `(eqv? 0.0 -0.0)' returned #f,
and `(equal? +nan.0 +nan.0)' returned #f but `(eqv? +nan.0 +nan.0)'
returned #t.
*** `(equal? +nan.0 +nan.0)' now returns #t
Previously, `(equal? +nan.0 +nan.0)' returned #f, although
`(let ((x +nan.0)) (equal? x x))' and `(eqv? +nan.0 +nan.0)'
both returned #t. R5RS requires that `equal?' behave like
`eqv?' when comparing numbers.
*** Change in handling products `*' involving exact 0
scm_product `*' now handles exact 0 differently. A product containing
an exact 0 now returns an exact 0 if and only if the other arguments
are all exact. An inexact zero is returned if and only if the other
arguments are all finite but not all exact. If an infinite or NaN
value is present, a NaN value is returned. Previously, any product
containing an exact 0 yielded an exact 0, regardless of the other
arguments.
*** `expt' and `integer-expt' changes when the base is 0
While `(expt 0 0)' is still 1, and `(expt 0 N)' for N > 0 is still
zero, `(expt 0 N)' for N < 0 is now a NaN value, and likewise for
integer-expt. This is more correct, and conforming to R6RS, but seems
to be incompatible with R5RS, which would return 0 for all non-zero
values of N.
*** `expt' and `integer-expt' are more generic, less strict
When raising to an exact non-negative integer exponent, `expt' and
`integer-expt' are now able to exponentiate any object that can be
multiplied using `*'. They can also raise an object to an exact
negative integer power if its reciprocal can be taken using `/'.
In order to allow this, the type of the first argument is no longer
checked when raising to an exact integer power. If the exponent is 0
or 1, the first parameter is not manipulated at all, and need not
even support multiplication.
*** Infinities are no longer integers, nor rationals
scm_integer_p `integer?' and scm_rational_p `rational?' now return #f
for infinities, per R6RS. Previously they returned #t for real
infinities. The real infinities and NaNs are still considered real by
scm_real `real?' however, per R6RS.
*** NaNs are no longer rationals
scm_rational_p `rational?' now returns #f for NaN values, per R6RS.
Previously it returned #t for real NaN values. They are still
considered real by scm_real `real?' however, per R6RS.
*** `inf?' and `nan?' now throw exceptions for non-reals
The domain of `inf?' and `nan?' is the real numbers. Guile now signals
an error when a non-real number or non-number is passed to these
procedures. (Note that NaNs _are_ considered numbers by scheme, despite
their name).
*** `rationalize' bugfixes and changes
Fixed bugs in scm_rationalize `rationalize'. Previously, it returned
exact integers unmodified, although that was incorrect if the epsilon
was at least 1 or inexact, e.g. (rationalize 4 1) should return 3 per
R5RS and R6RS, but previously it returned 4. It also now handles
cases involving infinities and NaNs properly, per R6RS.
*** Trigonometric functions now return exact numbers in some cases
scm_sin `sin', scm_cos `cos', scm_tan `tan', scm_asin `asin', scm_acos
`acos', scm_atan `atan', scm_sinh `sinh', scm_cosh `cosh', scm_tanh
`tanh', scm_sys_asinh `asinh', scm_sys_acosh `acosh', and
scm_sys_atanh `atanh' now return exact results in some cases.
*** New procedure: `finite?'
Add scm_finite_p `finite?' from R6RS to guile core, which returns #t
if and only if its argument is neither infinite nor a NaN. Note that
this is not the same as (not (inf? x)) or (not (infinite? x)), since
NaNs are neither finite nor infinite.
*** R6RS base library changes
**** `div', `mod', `div-and-mod', `div0', `mod0', `div0-and-mod0'
Efficient versions of these R6RS division operators are now supported.
See the NEWS entry entitled `Added two new sets of fast quotient and
remainder operators' for more information.
**** `infinite?' changes
`infinite?' and `finite?' now throw exceptions for non-numbers. (Note
that NaNs _are_ considered numbers by scheme, despite their name).
**** `real-valued?', `rational-valued?' and `integer-valued?' changes
These predicates are now implemented in accordance with R6RS.
** R6RS textual I/O procedures raise R6RS error conditions
R6RS procedures `get-char', `put-string', etc. now raise the correct
R6RS error coding, i.e., `&i/o-decoding-error' or `&i/o-encoding-error'.
** New reader option: `hungry-eol-escapes'
Guile's string syntax is more compatible with R6RS when the
`hungry-eol-escapes' option is enabled. See "String Syntax" in the
manual, for more information.
** And of course, the usual collection of bugfixes
Interested users should see the ChangeLog for more information.
You can follow Guile development in the Git repository and on the Guile
mailing lists. Guile builds from the `master' branch of Git have
version number 1.9.x.
Guile versions with an odd middle number, e.g., 1.9.*, are unstable
development versions. Even middle numbers indicate stable versions.
This has been the case since the 1.3.* series.
Please report bugs to address@hidden'. We also welcome reports of
successful builds, which can be sent to the same email address.
Ludovic Courtès, on behalf of the Guile team.
pgpjg4ONomic0.pgp
Description: PGP signature
- GNU Guile 1.9.15 released — last call before 2.0!,
Ludovic Courtès <=