Re: Placement of defines

Re: Placement of defines

[Kjetil S. Matheussen]

Sebastian Tennant:
>
> Hi all,
>
> Having read this interesting thread:
>
> http://sourceware.org/ml/guile/1999-08/msg00118.html
>
> I understand that internal definitions may not occur anywhere other than
> at the beginning of the body of the enclosing expression, which explains
> why this works:
>
> ((lambda (x) (define bar x) (display bar)) "foo\n")
>
> while this doesn't:
>
> ((lambda (x) (set! x "baz\n") (define bar x) (display bar)) "foo\n")
>
> Firstly, perhaps this could/should be mentioned in the manual?
>
> (info "(guile) Internal Definitions") currently reads:
>
> "A `define' form which appears inside the body of a `lambda', `let',
> `let*', `letrec' or equivalent expression is called an "internal
> definition"."
>
> May I suggest this reads:
>
> "`Define' forms may only appear at the beginning of the body of a
> `lambda', `let', `let*', `letrec' or equivalent expression, and when
> they do they constitute what are known as "internal definitions"."
>
> or words to that effect.
>

That's definitely an improvement!



> Secondly, there is some talk in the above-mentioned thread of an
> extension to R5RS Scheme that allows define forms to occur anywhere
> within the body of the enclosing expression, making for much more
> readable code.
>
> The thread is approx 8.5 years old now, and I was just wondering why the
> extension never made it into Guile, the readable code argument being a
> pretty compelling one IMHO.
>

Yes, this limitation in Scheme is a horrible pest. There's no
decent reason why you shouldn't be allowed to use define other
places than right after a lambda, except the long discussion
involved how it should behave in various situations. But even
inconsistant behaviour between implementations would be better
than the current situation where you either have to rewrite
perfectly fine expressions or use various types of lets or
lambdas in more or less ridiculous ways:

- ((lambda (x) (set! x "baz\n") (define bar x) (display bar)) "foo\n")
+ ((lambda (x) (set! x "baz\n") (let () (define bar x) (display bar) "foo\n"))

Re: Placement of defines

[Sebastian Tennant]

Quoth "Kjetil S. Matheussen" <k.s.matheussen@notam02.no>:
> Yes, this limitation in Scheme is a horrible pest. There's no
> decent reason why you shouldn't be allowed to use define other
> places than right after a lambda, except the long discussion
> involved how it should behave in various situations. But even
> inconsistant behaviour between implementations would be better
> than the current situation where you either have to rewrite
> perfectly fine expressions or use various types of lets or
> lambdas in more or less ridiculous ways:
>
> - ((lambda (x) (set! x "baz\n") (define bar x) (display bar)) "foo\n")
> + ((lambda (x) (set! x "baz\n") (let () (define bar x) (display bar) "foo\n"))

Your 'let' workaround gave me an idea.

I use this macro to bind lots of variables dynamically within my
scripts by wrapping calls to it in a map procedure:

 (define-macro (definer var val)                  ;var must be a symbol
   `(module-define! (current-module) ,var ,val))

and it happens to work fine as a workaround for the restriction on
define placements in lambdas and lets :)

 guile> ((lambda (x) (set! x "baz\n") (definer 'bar x) (display bar)) "foo\n")
 baz
 guile> 

It (the macro) won't work properly if you need/want to compile your
scheme code though.

If that's the case you should use this macro instead:

 (define-macro (definer var val)                  ;var must be a string
   `(define ,(string->symbol var) ,val))

I prefer the former macro definition because I don't need to compile my
code and

 (definer "foo" "bar")

seems somehow uglier and less intuitive than:

 (definer 'foo "bar")

to me.

Incidentally, perhaps you can tell me why the first argument to this
compile-friendly macro has to be a string for it to work.

 guile> (define-macro (definer var val)
          `(define ,var ,val))
 guile> (definer 'foo "bar")

appears to have worked, but...

 guile> foo
 ERROR: Unbound variable: foo
 ABORT: (unbound-variable)

it hasn't.

Sebastian

Re: Placement of defines

[Ludovic Courtès]

Sebastian Tennant <sebyte@smolny.plus.com> writes:

> Incidentally, perhaps you can tell me why the first argument to this
> compile-friendly macro has to be a string for it to work.
>
>  guile> (define-macro (definer var val)
>           `(define ,var ,val))
>  guile> (definer 'foo "bar")
>
> appears to have worked, but...
>
>  guile> foo
>  ERROR: Unbound variable: foo
>  ABORT: (unbound-variable)

Try this:

  (definer foo "bar")

Thanks,
Ludo'.

Re: Placement of defines

[Sebastian Tennant]

Quoth ludo@gnu.org (Ludovic Courtès):
> Sebastian Tennant <sebyte@smolny.plus.com> writes:
>
>> Incidentally, perhaps you can tell me why the first argument to this
>> compile-friendly macro has to be a string for it to work.
>>
>>  guile> (define-macro (definer var val)
>>           `(define ,var ,val))
>>  guile> (definer 'foo "bar")
>>
>> appears to have worked, but...
>>
>>  guile> foo
>>  ERROR: Unbound variable: foo
>>  ABORT: (unbound-variable)
>
> Try this:
>
>   (definer foo "bar")

Yes it works.

Damn.

After much experimenting and head scratching...

Question: When is a variable not a variable?

  Answer: When it's about to become the name of a variable.

:)

Seb

Re: Placement of defines

[Kjetil S. Matheussen]

Sebastian Tennant:
>
> Quoth "Kjetil S. Matheussen" <k.s.matheussen@notam02.no>:
>> Yes, this limitation in Scheme is a horrible pest. There's no
>> decent reason why you shouldn't be allowed to use define other
>> places than right after a lambda, except the long discussion
>> involved how it should behave in various situations. But even
>> inconsistant behaviour between implementations would be better
>> than the current situation where you either have to rewrite
>> perfectly fine expressions or use various types of lets or
>> lambdas in more or less ridiculous ways:
>>
>> - ((lambda (x) (set! x "baz\n") (define bar x) (display bar)) "foo\n")
>> + ((lambda (x) (set! x "baz\n") (let () (define bar x) (display bar) "foo\n"))
>
> Your 'let' workaround gave me an idea.
>
> I use this macro to bind lots of variables dynamically within my
> scripts by wrapping calls to it in a map procedure:
>
> (define-macro (definer var val)                  ;var must be a symbol
>   `(module-define! (current-module) ,var ,val))
>
> and it happens to work fine as a workaround for the restriction on
> define placements in lambdas and lets :)
>
> guile> ((lambda (x) (set! x "baz\n") (definer 'bar x) (display bar)) "foo\n")
> baz
> guile>
>

Unfortunately, it's not the same. "definer" defines a global variable:

guile> bar
"baz
"

Re: Placement of defines

[Sebastian Tennant]

Quoth "Kjetil S. Matheussen" <k.s.matheussen@notam02.no>:
>> Sebastian Tennant:
>> guile> ((lambda (x) (set! x "baz\n") (definer 'bar x) (display bar)) "foo\n")
>> baz
>> guile>
>>
>
> Unfortunately, it's not the same. "definer" defines a global variable:
>
> guile> bar
> "baz
> "

Good point.  That hadn't occurred to me.  Thanks.

Seb

Placement of defines

[Sebastian Tennant]

Hi all,

Having read this interesting thread:

 http://sourceware.org/ml/guile/1999-08/msg00118.html

I understand that internal definitions may not occur anywhere other than
at the beginning of the body of the enclosing expression, which explains
why this works:

 ((lambda (x) (define bar x) (display bar)) "foo\n")

while this doesn't:

 ((lambda (x) (set! x "baz\n") (define bar x) (display bar)) "foo\n")

Firstly, perhaps this could/should be mentioned in the manual?

(info "(guile) Internal Definitions") currently reads:

"A `define' form which appears inside the body of a `lambda', `let',
 `let*', `letrec' or equivalent expression is called an "internal
 definition"."

May I suggest this reads:

"`Define' forms may only appear at the beginning of the body of a
 `lambda', `let', `let*', `letrec' or equivalent expression, and when
 they do they constitute what are known as "internal definitions"."

or words to that effect.

Secondly, there is some talk in the above-mentioned thread of an
extension to R5RS Scheme that allows define forms to occur anywhere
within the body of the enclosing expression, making for much more
readable code.

The thread is approx 8.5 years old now, and I was just wondering why the
extension never made it into Guile, the readable code argument being a
pretty compelling one IMHO.

Sebastian