NEWS for 1.9.15 -> 2.0.0

NEWS for 1.9.15 -> 2.0.0

[Andy Wingo]

Hi all,

I was thinking that for 2.0, the NEWS that we would post would be
cumulative: all the changes of note that a user of 1.8 will see when
upgrading to 2.0.

But there have been some changes since the 1.9.15, so I figured I'd post
them here separately:


Changes since the 1.9.15 prerelease:

** `unquote' and `unquote-splicing' accept multiple expressions
    
As per the R6RS, these syntax operators can now accept any number of
expressions to unquote.

** `getopt-long' parsing errors throw to `quit', not `misc-error'

This change should inhibit backtraces on argument parsing errors.
`getopt-long' has been modified to print out the error that it throws
itself.

** New helpers: `print-exception', `set-exception-printer!'

These functions implement an extensible exception printer.  Guile
registers printers for all of the exceptions it throws.  Users may add
their own printers.  There is also `scm_print_exception', for use by C
programs.  Pleasantly, this allows SRFI-35 and R6RS exceptions to be
printed appropriately.

** `positions' reader option enabled by default
    
This change allows primitive-load without --auto-compile to also
propagate source information through the expander, for better errors and
to let macros know their source locations.  The compiler was already
turning it on anyway.

** `load' is a macro (!) that resolves paths relative to source file dir
    
The familiar Schem `load' procedure is now a macro that captures the
name of the source file being expanded, and dispatches to the new
`load-in-vicinity'.  Referencing `load' by bare name returns a closure
that embeds the current source file name.

This fix allows `load' of relative paths to be resolved with respect to
the location of the file that calls `load'.

** "autocompile" -> "auto-compile"

The "--autocompile" and "--no-autocompile" arguments were renamed to
have a dash, for consistency with the GUILE_AUTO_COMPILE environment
variable, and with common conventions.  A number of variables were also
appropriately renamed.
    
** `scm_primitive_load' defaults to UTF-8, not Latin-1
    
Like `compile-file', `primitive-load' now defaults to UTF-8.

** Warning now available for auto-compiled files.

See the `%auto-compilation-options' variable.  Warnings at
auto-compilation time are preceded with the `*current-warning-prefix*'
(a fluid).
    
** Deprecated: primitive properties

The `primitive-make-property', `primitive-property-set!',
`primitive-property-ref', and `primitive-property-del!' procedures were
crufty and only used to implement object properties, which has a new,
threadsafe implementation.  Use object properties or weak hash tables
instead.

** New syntax: define-once

`define-once' is like Lisp's `defvar': it creates a toplevel binding,
but only if one does not exist already.

** Added four new sets of fast quotient and remainder operators

Added four new sets of fast quotient and remainder operators 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.  Each set of operators computes an integer quotient
Q and a real remainder R such that N = Q*D + R and |R| < |D|.  They
differ only in how N/D is rounded to produce Q.

`floor-quotient' and `floor-remainder' compute Q and R, respectively,
where Q has been rounded toward negative infinity.  `floor/' returns
both Q and R, and is more efficient than computing each separately.
Note that when applied to integers, `floor-remainder' is equivalent to
the R5RS integer-only `modulo' operator.  `ceiling-quotient',
`ceiling-remainder', and `ceiling/' are similar except that Q is
rounded toward positive infinity.

For `truncate-quotient', `truncate-remainder', and `truncate/', Q is
rounded toward zero.  Note that when applied to integers,
`truncate-quotient' and `truncate-remainder' are equivalent to the
R5RS integer-only operators `quotient' and `remainder'.

For `round-quotient', `round-remainder', and `round/', Q is rounded to
the nearest integer, with ties going to the nearest even integer.

** Improved exactness handling for complex number parsing

When parsing non-real complex numbers, exactness specifiers are now
applied to each component, as is done in PLT Scheme.  For complex
numbers written in rectangular form, exactness specifiers are applied
to the real and imaginary parts before calling scm_make_rectangular.
For complex numbers written in polar form, exactness specifiers are
applied to the magnitude and angle before calling scm_make_polar.

Previously, exactness specifiers were applied to the number as a whole
_after_ calling scm_make_rectangular or scm_make_polar.

For example, (string->number "#i5.0+0i") now does the equivalent of:

  (make-rectangular (exact->inexact 5.0) (exact->inexact 0))

which yields 5.0+0.0i.  Previously it did the equivalent of:

  (exact->inexact (make-rectangular 5.0 0))

which yielded 5.0.




Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2006 Free Software Foundation, Inc.

   Permission is granted to anyone to make or distribute verbatim copies
   of this document as received, in any medium, provided that the
   copyright notice and this permission notice are preserved,
   thus giving the recipient permission to redistribute in turn.

   Permission is granted to distribute modified versions
   of this document, or of portions of it,
   under the above conditions, provided also that they
   carry prominent notices stating who last changed them.

-- 
http://wingolog.org/

Re: NEWS for 1.9.15 -> 2.0.0

[Mark H Weaver]

Andy Wingo <wingo@pobox.com> wrote:
> I was thinking that for 2.0, the NEWS that we would post would be
> cumulative: all the changes of note that a user of 1.8 will see when
> upgrading to 2.0.

Here is a combined NEWS entry for the new division operators.

    Mark


** Added new number-theoretic division operators

Added six new sets of fast quotient and remainder operators 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.  Each set of operators computes an integer quotient
Q and a real remainder R such that N = Q*D + R and |R| < |D|.  Four
sets are defined in terms of the rounding mode used to choose the
integer Q near N/D, and two are defined in terms of the allowable
range of R.

`floor-quotient' and `floor-remainder' compute Q and R, respectively,
where Q has been rounded toward negative infinity.  `floor/' returns
both Q and R, and is more efficient than computing each separately.
Note that when applied to integers, `floor-remainder' is equivalent to
the R5RS integer-only `modulo' operator.  `ceiling-quotient',
`ceiling-remainder', and `ceiling/' are similar except that Q is
rounded toward positive infinity.

For `truncate-quotient', `truncate-remainder', and `truncate/', Q is
rounded toward zero.  Note that when applied to integers,
`truncate-quotient' and `truncate-remainder' are equivalent to the
R5RS integer-only operators `quotient' and `remainder'.

For `round-quotient', `round-remainder', and `round/', Q is rounded to
the nearest integer, with ties going to the nearest even integer.

`euclidean-quotient', `euclidean-remainder', and `euclidean/' are
defined by the constraint 0 <= R < |D|.  They are equivalent to the
R6RS operators `div', `mod', and `div-and-mod'.

`centered-quotient', `centered-remainder', and `centered/' are defined
by the constraint -|D/2| <= R < |D/2|.  They are equivalent to the R6RS
operators `div0', `mod0', and `div-and-mod0'.