On 11 Dec 2010, at 01:25, Neil Jerram wrote:
The reply I got was helpful, but I decided to settle for a macro
implementation:
(use-syntax (ice-9 syncase))
(define-syntax tuple
(syntax-rules ()
((tuple xs ...)
`(tuple ,xs ...))
((tuple x1 x2 . y)
(append `(tuple ,x1 ,x2) y))
((tuple x1 . y)
(append `(tuple ,x1) y))
))
OK, I roughly see that this solves your problem of wanting to
unquote an
arbitrary number of list elements. (Although I don't understand why
you
need to do that.)
One reason is that in the normal syntax f(x_1, ..., x_k) there are two
separate parts f and (x_1, ..., x_k) that are combined, whereas in
Scheme it is combined to one (f x_1 ... x_k) and does not have a
concept for the (x_1, ..., x_k). Another is that it is needed in the
translation of expressions like f(g(x)) --> (f (g x)), and (f g)x -->
((f g) x).
It behaves as I want in my context, a functional language on top of
Guile.
Scheme is already a functional language, isn't it?
I am using Bison/Flex parser/lexer to generate a different syntax. It
turns out to be a good help not having to implement the back-end.
I decided to implement the construct (lambda (x_1 ... x_k . y)
f)
What syntax is that expression in? In Scheme syntax, it's a lambda
that
returns a value that is apparently unrelated to any of the arguments,
and so could equally well be written as (lambda ignored-args f).
I implement it using Guile C calls, and when constructing using
scm_list_3(scm_sym_lambda, x, f), it turns out that x = (x_1 ... x_k .
y) is an improper list.
using an improper list (x_1 ... x_k . y); when it is a proper list,
one just gets the fixed number of arguments construct.
Then the object (x_1 ... x_k . y) also become available, so it is
possible to form
(define f (lambda (x_1 ... x_k . y) (x_1 ... x_k . y)))
How is this different from
(define f (lambda args args))
?
The form (x_1 ... x_k . y) is an improper list that requires at least
k arguments, and the rest given arguments are put into y as a list.
Then one would expect f(a_1, ..., a_n), for n >= k, to be (a_1, ...,
a_n) - this a form of the identity.
So to get this effect, I need a function g that can call improper
lists (g x_1, ..., x_k . y), where y is a list.
As Dan pointed out, that is not an improper list. It's a proper list.
That would be true if the evaluator does not try to evaluate the
expression before the substitution of y. That works in the case of a
freestanding (g x_1 ... x_k . y), but for some reason not in the form
(lambda (x_1 ... x_k . y) (g x_1 ... x_k . y))
I do not know why.
In the hope that these questions might be useful to at least one of
us...
I do not know what that means.
