Re: Anything better for delayed lexical evaluation than (lambda () ...)?

[rixed]

> > and that other programs that use Guile for extension will run into
> > similar difficulties, but as far as I can tell Lilypond is quite
> > unique here.
> 
> Because nobody else uses Guile for serious extensions.  And not because
> of its performance: that is _irrelevant_ for most extension purposes.
> The performance angle is interesting when one uses Guile as a general
> purpose _programming_ language.  You are sacrificing your target
> clientele here.

Obviously Guile does not suffer from too many users right now, but stating
that Lilypond is the only project using Guile seriously seams a little
excessive.

Be confident that I'm ashamed by my ignorance but I do not know how
exactly Lilypond uses Guile (nor what Lilypond exactly does), but your
description of it does sound like it's the only way to "extend" a
program.  You seams to view an extension language as a tool to extend a
language, while many projects use guile merely to extend a program.  So
let me present you the view of the average Joe Schemer with regard to
Guile as an extension language: For me, extending a program (supposedly
written in some kind of low level language, let's say some kind of C)
with Guile or any other higher level language, is the action of linking
together the low level stuff and libguile in a way that some scheme
programs can be run with easy access to the inner functionalities of the
program, so that :

- the poor maintainers of the old C-like program are not forced to code
  every trivia in C-like language
- the poor users are given an easier way to configure and even program
  the old C dinosaur
- if time permits, evolve from extending the C with Scheme to extending
  the Scheme with C, so that not only the C program can access all
  scheme facilities and libraries, but also all other programs can use
  the internal of the old C program (this being only possible if you
  have only one extension language)

In that regard, having Guile being compiled to bytecode, to native,
interpreted, JITed or whatever is irrelevant. Indeed, it's also
quite irrelevant if it's scheme or anything else, but :

- the more expressiveness we have the better
- the faster the better
- the more available front-end languages, the less frightened the users
  will be (if not less parentheses then at least at there usual
  locations...)

In my experience these two elements played a great role in the
acceptance of Guile (over Lua, mainly) as the extension language.
I don't pretend you were wrong to use Guile as you did of course!

My 2c, which is not a lot per line, just to let you know that
some projects are indeed enjoying their migration from guile 1.8
to guile 2.