definition in expression context, where definitions are not allowed

definition in expression context, where definitions are not allowed

[Arne Babenhauserheide]

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

Hi,

I’m repeatedly stumbling over the restrictions where to use define. Here’s a minimal example:

    (define (hello who)
      (display "Hello ")
      (define (world who)
        (display who))
      (world who)
      (display "!")
      (newline))

This throws a Syntax error: …definition in expression context, where
definitions are not allowed, in form (define (world who) (display
who))

And though I know that there are reasons for this, it just feels wrong
to be in the language which removes restrictions for writing great
languages and then seeing such a complication.

This works just fine - keeping all the information in the definition -
when I rewrite it to

    (define (hello who)
      (display "Hello ")
      (let ((world (lambda (who) (display who))))
        (world who)
        (display "!")
        (newline)))

So why isn’t that done automatically? Why does Guile not just do this
transformation with an information message that the define was changed
to a let? It already detects the situation, why can’t it make it work?

In other words: Is the optimization allowed by this worth the
additional complexity of the language?

Or am I missing something else which is enabled by this limitation?

Best wishes,
Arne

[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 299 bytes --]

Re: definition in expression context, where definitions are not allowed

[Taylan Ulrich Bayırlı/Kammer]

Arne Babenhauserheide <arne_bab@web.de> writes:

>     (define (hello who)
>       (display "Hello ")
>       (define (world who)
>         (display who))
>       (world who)
>       (display "!")
>       (newline))

Let's look at a different example first, which works with the current
semantics:

  (let ()
    (define (odd? n) (if (zero? n) #f (even? (- n 1))))
    (define (even? n) (if (zero? n) #t (odd? (- n 2))))
    (even? 42))

That works because the internal definitions become 'letrec*' so they may
refer to each other, i.e. 'odd?' can refer to 'even?' in its body,
before 'even?' is really defined.

If your example also worked, than with the combination of the above,
users might ultimately also expect this to work:

  (let ()
    (define (hello)
      (display "Hello ")
      (world)
      (display "!")
      (newline))
    (display "Goodbye Eden, ")
    (define (world)
      (display "World"))
    (hello))

Just like in the top-level.  But that would require making the whole
procedure body a big 'letrec*' expression.  If I'm not mistaken that's
exactly what JavaScript does, called "var hoisting," where all variables
declared anywhere in a function become bound to a special 'undefined'
value at the beginning of the function, and these don't behave exactly
as undefined variables either.  In Guile too, variables "bound but not
defined yet" as created by 'letrec*' aren't checked for invalid access
because it would put overhead on every variable reference.  So that
would end up giving us those weird semantics as known from JS.

(IIRC, "strict mode" JS only allows variable declarations at the
beginning of a function body, just like internal defines in Scheme.)

Or maybe my example was a bit contrived, and/or we can teach users that
they should "group together" definitions that refer to each other, and
have those groups turn into nested 'letrec*' expressions (similar to
your proposal, just using 'letrec*' when there's multiple adjacent
'define' forms).  But that makes things more and more complicated, and
by the time we taught users that we could have probably just taught them
the simpler rule that internal 'define' forms may only appear at the
beginning of a body.

Does that make sense?

Taylan