ongoing NEWS

ongoing NEWS

[Andy Wingo]

Hey,

Not yet done with my part of the NEWS, though I hope to finish by noon
or so tomorrow. But here is some of what I have, for review:

** The stack limit is now initialized from the environment.

If getrlimit(2) is available and a stack limit is set, Guile will set
its stack limit to 80% of the rlimit. Otherwise the limit is 160000
words, a four-fold increase from the earlier default limit.

** Fix bad interaction between `false-if-exception' and stack-call.

Exceptions thrown by `false-if-exception' were erronously causing the
stack to be saved, causing later errors to show the incorrectly-saved
backtrace. This has been fixed.

** Files loaded with primitive-load-path will now be compiled
   automatically.

If a compiled .go file corresponding to a .scm file is not found or is
not fresh, the .scm file will be compiled on the fly, and the resulting
.go file stored away. An advisory note will be printed on the console.

Note that this mechanism depends on preservation of the .scm and .go
modification times; if the .scm or .go files are moved after
installation, care should be taken to preserve their original
timestamps.

Autocompiled files will be stored in the user's ~/.guile-ccache
directory, which will be created if needed. This is analogous to
ccache's behavior for C files.

To inhibit autocompilation, set the GUILE_AUTO_COMPILE environment
variable to 0, or pass --no-autocompile on the Guile command line.

** New environment variables: GUILE_LOAD_COMPILED_PATH,
   GUILE_SYSTEM_LOAD_COMPILED_PATH

GUILE_LOAD_COMPILED_PATH is for compiled files what GUILE_LOAD_PATH is
for source files. It is a different path, however, because compiled
files are architecture-specific. GUILE_SYSTEM_LOAD_COMPILED_PATH is like
GUILE_SYSTEM_PATH.

** New global variables: %load-compiled-path, %load-compiled-extensions

These are analogous to %load-path and %load-extensions.

** New installation directory: $(pkglibdir)/1.9/ccache

If $(libdir) is /usr/lib, for example, Guile will install its .go files
to /usr/lib/guile/1.9/ccache. These files are architecture-specific.

** scm_primitive_load_path has additional argument, exception_on_error

** scm_stat has additional argument, exception_on_error

** New entry into %guile-build-info: `ccachedir'

Probably should be removed?

** New reader macros: #' #` #, #,@

These macros translate, respectively, to `syntax', `quasisyntax',
`unsyntax', and `unsyntax-splicing'. See the R6RS for more information.
These reader macros may be overridden by `read-hash-extend'.

** Incompatible change to #'

Guile did have a #' hash-extension, by default, which just returned the
subsequent datum: #'foo => foo. In the unlikely event that anyone
actually used this, this behavior may be reinstated via the
`read-hash-extend' mechanism.

** Scheme expresssions may be commented out with #;

#; comments out an entire expression. See the R6RS for more information.

** make-stack with a tail-called procedural narrowing argument no longer
   works (with compiled procedures)

It used to be the case that a captured stack could be narrowed to select
calls only up to or from a certain procedure, even if that procedure
already tail-called another procedure. This was because the debug
information from the original procedure was kept on the stack.

Now with the new compiler, the stack only contains active frames from
the current continuation. A narrow to a procedure that is not in the
stack will result in an empty stack. To fix this, narrow to a procedure
that is active in the current continuation, or narrow to a specific
number of stack frames.

** backtraces through compiled procedures only show procedures that are
   active in the current continuation

Similarly to the previous issue, backtraces in compiled code may be
different from backtraces in interpreted code. There are no semantic
differences, however. Please mail bug-guile@gnu.org if you see any
deficiencies with Guile's backtraces.

** syntax-rules and syntax-case macros now propagate source information
   through to the expanded code

This should result in better backtraces.

** The currying behavior of `define' has been removed.

Before, `(define ((f a) b) (* a b))' would translate to

  (define f (lambda (a) (lambda (b) (* a b))))

Now a syntax error is signalled, as this syntax is not supported by
default. If there is sufficient demand, this syntax can be supported
again by default.

** All modules have names now

Before, you could have anonymous modules: modules without names. Now,
because of hygiene and macros, all modules have names. If a module was
created without a name, the first time `module-name' is called on it, a
fresh name will be lazily generated for it.

** Many syntax errors have different texts now

Syntax errors still throw to the `syntax-error' key, but the arguments
are often different now. Perhaps in the future, Guile will switch to
using standard srfi-35 conditions.

** Returning multiple values to compiled code will silently truncate the
   values to the expected number

For example, the interpreter would raise an error evaluating the form,
`(+ (values 1 2) (values 3 4))', because it would see the operands as
being two compound "values" objects, to which `+' does not apply.

The compiler, on the other hand, receives multiple values on the stack,
not as a compound object. Given that it must check the number of values
anyway, if too many values are provided for a continuation, it chooses
to truncate those values, effectively evaluating `(+ 1 3)' instead.

The idea is that the semantics that the compiler implements is more
intuitive, and the use of the interpreter will fade out with time.
This behavior is allowed both by the R5RS and the R6RS.

** Multiple values in compiled code are not represented by compound
   objects

This change may manifest itself in the following situation:

  (let ((val (foo))) (do-something) val)

In the interpreter, if `foo' returns multiple values, multiple values
are produced from the `let' expression. In the compiler, those values
are truncated to the first value, and that first value is returned. In
the compiler, if `foo' returns no values, an error will be raised, while
the interpreter would proceed.

Both of these behaviors are allowed by R5RS and R6RS. The compiler's
behavior is more correct, however. If you wish to preserve a potentially
multiply-valued return, you will need to set up a multiple-value
continuation, using `call-with-values'.

** Defmacros are now implemented in terms of syntax-case.

The practical ramification of this is that the `defmacro?' predicate has
been removed, along with `defmacro-transformer', `macro-table',
`xformer-table', `assert-defmacro?!', `set-defmacro-transformer!' and
`defmacro:transformer'. This is because defmacros are simply macros. If
any of these procedures provided useful facilities to you, we encourage
you to contact the Guile developers.

** psyntax is now the default expander

Scheme code is now expanded by default by the psyntax hygienic macro
expander. Expansion is performed completely before compilation or
interpretation.

Notably, syntax errors will be signalled before interpretation begins.
In the past, many syntax errors were only detected at runtime if the
code in question was memoized.

As part of its expansion, psyntax renames all lexically-bound
identifiers. Original identifier names are preserved and given to the
compiler, but the interpreter will see the renamed variables, e.g.,
`x432' instead of `x'.

Note that the psyntax that Guile uses is a fork, as Guile already had
modules before incompatible modules were added to psyntax -- about 10
years ago! Thus there are surely a number of bugs that have been fixed
in psyntax since then. If you find one, please notify bug-guile@gnu.org.

** syntax-rules and syntax-case are available by default.

There is no longer any need to import the `(ice-9 syncase)' module
(which is now deprecated). The expander may be invoked directly via
`sc-expand', though it is normally searched for via the current module
transformer.

Also, the helper routines for syntax-case are available in the default
environment as well: `syntax->datum', `datum->syntax',
`bound-identifier=?', `free-identifier=?', `generate-temporaries',
`identifier?', and `syntax-violation'. See the R6RS for documentation.

** Lexical bindings introduced by hygienic macros may not be referenced
   by nonhygienic macros.

If a lexical binding is introduced by a hygienic macro, it may not be
referenced by a nonhygienic macro. For example, this works:

  (let ()
    (define-macro (bind-x val body)
      `(let ((x ,val)) ,body))
    (define-macro (ref x)
      x)
    (bind-x 10 (ref x)))

But this does not:

  (let ()
    (define-syntax bind-x
      (syntax-rules ()
        ((_ val body) (let ((x val)) body))))
    (define-macro (ref x)
      x)
    (bind-x 10 (ref x)))

It is not normal to run into this situation with existing code. However,
as code is ported over from defmacros to syntax-case, it is possible to
run into situations like this. In the future, Guile will probably port
its `while' macro to syntax-case, which makes this issue one to know
about.

** Macros may no longer be referenced as first-class values.

In the past, you could evaluate e.g. `if', and get its macro value. Now,
expanding this form raises a syntax error.

Macros still /exist/ as first-class values, but they must be
/referenced/ via the module system, e.g. `(module-ref (current-module)
'if)'.

This decision may be revisited before the 2.0 release. Feedback welcome
to guile-devel@gnu.org (subscription required) or bug-guile@gnu.org (no
subscription required).

** New macro type: syncase-macro

XXX Need to decide whether to document this for 2.0, probably should:
make-syncase-macro, make-extended-syncase-macro, macro-type,
syncase-macro-type, syncase-macro-binding

** `(ice-9 syncase)' has been deprecated.

As syntax-case is available by default, importing `(ice-9 syncase)' has
no effect, and will trigger a deprecation warning.

** Fix bug in `module-bound?'.

`module-bound?' was returning true if a module did have a local
variable, but one that was unbound, but another imported module bound
the variable. This was an error, and was fixed.

** BUG: Automatic compilation will be attempted when it shouldn't.

For example, the old (lang elisp) modules are meant to be interpreted,
not compiled. This bug will be fixed before 2.0.

Andy
-- 
http://wingolog.org/

Re: ongoing NEWS

[Andreas Rottmann]

Andy Wingo <wingo@pobox.com> writes:

> Autocompiled files will be stored in the user's ~/.guile-ccache
> directory, which will be created if needed. This is analogous to
> ccache's behavior for C files.
>
As long as nothing is set in stone, perhaps you want to consider
following the XDG basedir spec[0], which would suggest using something
under ~/.cache/ per default; this would make e.g. having reasonable
backup policies easier, as stuff under ~/.cache can be safely ignored
for backups, and it avoids cluttering $HOME with yet-another
dotfile/dotdir (although that is somewhat of a lost cause on GNU/Linux
anyway).

> ** psyntax is now the default expander
> ** syntax-rules and syntax-case are available by default.
>
Yey! :-)

Cheers, Rotty

Re: ongoing NEWS

[Neil Jerram]

Andreas Rottmann <a.rottmann@gmx.at> writes:

> As long as nothing is set in stone, perhaps you want to consider
> following the XDG basedir spec[0], which would suggest using something
> under ~/.cache/ per default; this would make e.g. having reasonable
> backup policies easier, as stuff under ~/.cache can be safely ignored
> for backups, and it avoids cluttering $HOME with yet-another
> dotfile/dotdir

I'd like this too.

> (although that is somewhat of a lost cause on GNU/Linux
> anyway).

It's incremental; if we can avoid one new piece of arbitrariness, I
think that's worthwhile.

Regards,
        Neil

Re: ongoing NEWS

[Andy Wingo]

On Thu 18 Jun 2009 23:49, Andreas Rottmann <a.rottmann@gmx.at> writes:

> Andy Wingo <wingo@pobox.com> writes:
>
>> Autocompiled files will be stored in the user's ~/.guile-ccache
>> directory, which will be created if needed. This is analogous to
>> ccache's behavior for C files.
>>
> As long as nothing is set in stone, perhaps you want to consider
> following the XDG basedir spec[0], which would suggest using something
> under ~/.cache/ per default; this would make e.g. having reasonable
> backup policies easier, as stuff under ~/.cache can be safely ignored
> for backups, and it avoids cluttering $HOME with yet-another
> dotfile/dotdir (although that is somewhat of a lost cause on GNU/Linux
> anyway).

Sure, sounds like a good idea.

Andy
-- 
http://wingolog.org/