define-syntax

define-syntax

[Pach Roman (DGS-EC/ESG3)]

[-- Attachment #1: Type: text/plain, Size: 779 bytes --]

I've performed following two short tests.

test 1:
-------

(use-syntax (ice-9 syncase))

(define-syntax my-macro-1
  (syntax-rules ()
    ((_ par1 par2 par3)
     (begin
	   (string-concatenate (list par1 par2 par3))
	   ))))

(define (dummy)
  (my-macro-1 "a" "b" "c"))

(format #t "dummy => ~s\n" (procedure-source dummy))

result:
dummy => (lambda () (string-concatenate (list "a" "b" "c")))

test 2:
-------
(define-macro (my-macro-2 par1 par2 par3)
  (string-concatenate (list par1 par2 par3)))

(define (dummy)
  (my-macro-2 "a" "b" "c")
  )
(dummy)
(format #t "dummy => ~s\n" (procedure-source dummy))

result:
dummy => (lambda () "abc")


It seems to me the define-syntax is broken in version "1.8.2"
or I've done something wrong.

[-- Attachment #2: Type: text/html, Size: 3011 bytes --]

Re: define-syntax

[Neil Jerram]

2008/12/9 Pach Roman (DGS-EC/ESG3) <Roman.Pach@de.bosch.com>:
> I've performed following two short tests.
>
> test 1:
> -------
>
> (use-syntax (ice-9 syncase))
>
> (define-syntax my-macro-1
>   (syntax-rules ()
>     ((_ par1 par2 par3)
>      (begin
>            (string-concatenate (list par1 par2 par3))
>            ))))
>
> (define (dummy)
>   (my-macro-1 "a" "b" "c"))
>
> (format #t "dummy => ~s\n" (procedure-source dummy))
>
> result:
> dummy => (lambda () (string-concatenate (list "a" "b" "c")))
>
> test 2:
> -------
> (define-macro (my-macro-2 par1 par2 par3)
>   (string-concatenate (list par1 par2 par3)))
>
> (define (dummy)
>   (my-macro-2 "a" "b" "c")
>   )
> (dummy)
> (format #t "dummy => ~s\n" (procedure-source dummy))
>
> result:
> dummy => (lambda () "abc")
>
> It seems to me the define-syntax is broken in version "1.8.2"
> or I've done something wrong.

These examples both look good to me.  Which one do you think is wrong?

It may help if I point out that define-macro usage usually involves
backquoting.  The define-macro version of your define-syntax example
would normally be:

 (define-macro (my-macro-2 par1 par2 par3)
   `(string-concatenate (list ,par1 ,par2 ,par3)))

Regards,
       Neil

AW: define-syntax

[Pach Roman (DGS-EC/ESG3)]

>> I've performed following two short tests.
>>
>> test 1:
>> -------
>>
>> (use-syntax (ice-9 syncase))
>>
>> (define-syntax my-macro-1
>>   (syntax-rules ()
>>     ((_ par1 par2 par3)
>>      (begin
>>            (string-concatenate (list par1 par2 par3))
>>            ))))
>>
>> (define (dummy)
>>   (my-macro-1 "a" "b" "c"))
>>
>> (format #t "dummy => ~s\n" (procedure-source dummy))
>>
>> result:
>> dummy => (lambda () (string-concatenate (list "a" "b" "c")))
>>
>> test 2:
>> -------
>> (define-macro (my-macro-2 par1 par2 par3)
>>   (string-concatenate (list par1 par2 par3)))
>>
>> (define (dummy)
>>   (my-macro-2 "a" "b" "c")
>>   )
>> (dummy)
>> (format #t "dummy => ~s\n" (procedure-source dummy))
>>
>> result:
>> dummy => (lambda () "abc")
>>
>> It seems to me the define-syntax is broken in version "1.8.2"
>> or I've done something wrong.
>
> These examples both look good to me.  Which one do you think is wrong?
>
> It may help if I point out that define-macro usage usually involves
> backquoting.  The define-macro version of your define-syntax example
> would normally be:
>
>  (define-macro (my-macro-2 par1 par2 par3)
>    `(string-concatenate (list ,par1 ,par2 ,par3)))
>
> Regards,
>       Neil

take look at the results

(1) dummy => (lambda () (string-concatenate (list "a" "b" "c")))
(2) dummy => (lambda () "abc")

in the case of define-syntax (1) the string "abc" will be computed at
the run time,
the macro version (2) hat produced the "abc" already by reading the
macro definition.
I've expected both of the be computed during the reading of scheme
source.

Re: define-syntax

[Neil Jerram]

2008/12/9 Pach Roman (DGS-EC/ESG3) <Roman.Pach@de.bosch.com>:
>
> take look at the results
>
> (1) dummy => (lambda () (string-concatenate (list "a" "b" "c")))
> (2) dummy => (lambda () "abc")
>
> in the case of define-syntax (1) the string "abc" will be computed at
> the run time,
> the macro version (2) hat produced the "abc" already by reading the
> macro definition.

Agreed.

> I've expected both of the be computed during the reading of scheme
> source.

That's not what define-syntax is supposed to do, as I understand it.
If you think we've got this wrong, can you point to something specific
in R5RS?

Regards,
      Neil

Re: AW: define-syntax

[Clinton Ebadi]

"Pach Roman (DGS-EC/ESG3)" <Roman.Pach@de.bosch.com> writes:

>>> test 2:
>>> -------
>>> (define-macro (my-macro-2 par1 par2 par3)
>>>   (string-concatenate (list par1 par2 par3)))

A macro defined with define-macro is merely a function that is run at
macroexpansion time and is expected to return a new form for the
compiler. The body of the macro can perform arbitrary computation, and
your macro is actually calling string-concatenate at macroexpansion time
rather than returning the form as you expected.

(define-macro (my-macro-2 par1 par2 par3)
   `(string-concatenate (list ,par1 ,par2, par3)))

Will do what you expect.

-- 
                     How can you accept social supression                      
                      This weak state of mind in our time                      
                        I demand release from hypocrisy                        
                 I'd rather die than be held down, forced down