Re: Backquote simplification
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.
Re: Backquote simplification
Hi Hans, To reply quickly to one point in your email... (I'll ponder the rest later.) Hans Aberg haber...@telia.com writes: On 11 Dec 2010, at 01:25, Neil Jerram wrote: In the hope that these questions might be useful to at least one of us... I do not know what that means. I meant that I'm sure I don't understand yet what you're doing, and hence that the answers might help me; and that there was a possibility that you might not be understanding some things, and that in that case the discussion might help you too. Regards, Neil
Re: Backquote simplification
On 11 Dec 2010, at 11:01, Neil Jerram wrote: To reply quickly to one point in your email... (I'll ponder the rest later.) Whenever you so want. In the hope that these questions might be useful to at least one of us... I do not know what that means. I meant that I'm sure I don't understand yet what you're doing, and hence that the answers might help me; and that there was a possibility that you might not be understanding some things, and that in that case the discussion might help you too. Yes, the replies are helpful, though I am programming also directly with Guile C calls involving unevaluated expressions.
Re: Backquote simplification
[Your reply does not seem to be on the list, so I cc it.] Thanks. I might try an iterated cons, that is a function f such such that (f x1 ... xk y) -- (cons x1 ... (cons xk y) ...)) Then (lambda (x1 ... xk . y) (f x1 ... xk y)) should just return at least k arguments as a list. I'm not sure right now how to write it, so thankful for help. On 9 Dec 2010, at 18:44, d...@mac.com wrote: Hi, You need not use quoting at all in these cases. ( 1 2 . ( 3 4 ) ) is exactly equivalent to ( 1 2 3 4 ) and ( 1 . ( 2 . ( 3 . ( 4 ) ) ) ) (b ( cons x y )) or (apply b x y) I cannot quite tell fom your example. Cheers, Dan
Re: Backquote simplification
Hans Aberg haber...@telia.com writes: [Your reply does not seem to be on the list, so I cc it.] Thanks. I might try an iterated cons, that is a function f such such that (f x1 ... xk y) -- (cons x1 ... (cons xk y) ...)) Isn't that just `list'? More generally: I've been reading your emails, but I'm afraid I have no idea what you are trying to do. Perhaps you could step back and explain that overall, before continuing with details. Neil
Re: Backquote simplification
On 11 Dec 2010, at 00:12, Neil Jerram wrote: [Your reply does not seem to be on the list, so I cc it.] Thanks. I might try an iterated cons, that is a function f such such that (f x1 ... xk y) -- (cons x1 ... (cons xk y) ...)) Isn't that just `list'? More generally: I've been reading your emails, but I'm afraid I have no idea what you are trying to do. Perhaps you could step back and explain that overall, before continuing with details. 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)) )) It behaves as I want in my context, a functional language on top of Guile. I decided to implement the construct (lambda (x_1 ... x_k . y) f) 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))) 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. For some reason, the substitution of the list y to get a list for the function g does not work in this situation, exception for the macro definition above, g = tuple. Then, there is another problem with this macro: if having the ., one cannot have ..., like would be needed say when implementing (define (f x_1 ... x_k . y) ...) expanding to (define f (lambda (x_1 ... x_k . y) ...) for any k. That is, the following isn't legal: (define-syntax tuple (syntax-rules () ((tuple xs ...) `(tuple ,xs ...)) ((tuple xs ... . y) `(tuple ,xs ... . ,y)) )) But if it would have been, it would produce what I want.
Re: Backquote simplification
Hans Aberg haber...@telia.com writes: 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.) 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 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). 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)) ? 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. In the hope that these questions might be useful to at least one of us... Neil
Backquote simplification
Is it possible to simplify the backquote construct `(,x_1 ... ,x_k) (always unquote on all arguments) somehow, so that the unquote does not need to appear multiple times (depending on k)? (I construct these in the C-interface, and it would simplify not having to remove a sequence of them.) Specifically, in (define g (lambda (x . y) `(,x . ,y))) then evaluations like (g 1 2 3), (g 1 2 . (3 4)) work. So I would want something like (define g (lambda (x . y) (b x . y where (b x . y) might be any expression where the unquote does not need to appear on every variable. Only combinations line (define g (lambda (x . y) (b `(,x . ,y seem to work. Hans
