DrSchemes use of local is boggling me.  How does it relate to "let" and
"lambda".

e.g. (from HTDP)
;; add : number -> (number -> number)
;; to create a function that adds x to its input
(define (add-0 x)
  (local ((define (x-adder y) (+ x y)))
    x-adder))

I would before had thought in terms of
(define (add-1 x)
  (lambda (y)(+ x y)))

or
(define (add-2 x)
  (define (x-adder y)(+ x y))
  x-adder)

or even
(define (add-3 x)
  (let ((x-adder (lambda(y)(+ x y))))
    x-adder))

So, what is local for?  How is add-2 any different from add-0?

  (define v1 ...)
  (define v2 ...)
  ...
  (define vn ...)

(whether or not they're bound to functions isn't relevant, ie, some
could be of the form (define (vk ...) ...); they can also be
structures created using define-struct).  Now you want to localize
their scope.  None of Scheme's existing constructs -- let, letrec,
internal defines -- preserves the semantics of the original.  local
does.  You can simply write

(local (
        (define v1 ...)
        (define v2 ...)
        ...
        (define vn ...)
                       )
  <expression> ...)

and its value would be the same as if you had written <expression>
after all the definitions sans the local.

- lambda only captures the case where you have a single function that
  you are returning immediately,

- let does not capture recursion, and

- letrec and internal definitions turn sequential definitions into
  parallel ones, thereby altering the result.

(If you understand the preceding bullets, then you will see why local
is different and useful.  If you don't understand the preceding
bullets, then you don't understand the semantics of Scheme's many
binding constructs adequately, and you're just the sort of person for
whom local is most useful in that it minimizes surprises.)

(begin (
   (define a 7)
   (define b 9)
  (+ a b))

Oops, I just answered my own question-- this defines a and b in global
scope!  Surprise to me.

But then

(local (
   (define c 12)
   (define d 13)
                )
  (+ c d))

Didn't work for me, I got:
"define-values: illegal use (not at top-level) in: (#%define-values (c)
12)"

Also, is there any particular discussion/chapter/etc you could point me
to to improve my "understanding of the semantics of Scheme's many
binding constructs"?  Or is this a topic that only comes through
experience of many k of code writing.

Thanks for your help,
John

I tend to think of this as a (standardized) bug in letrec, although I
am fairly sure that one of the mighty Matthiases would disagree.

where you essentially use the implicit begin provided by the explicit
introduction of the new scope. You could even hack up a define-syntax
for local ;)

david rush
--
[1] R5RS - "it must be possible to evaluate each <init> without
           assigning or referring to the value of any <variable>"

where you essentially use the implicit begin provided by the explicit
introduction of the new scope. You could even hack up a define-syntax
for local ;)

david rush
--
[1] R5RS - "it must be possible to evaluate each <init> without
           assigning or referring to the value of any <variable>"

david rush
--
[1] R5RS - "it must be possible to evaluate each <init> without
           assigning or referring to the value of any <variable>"

We decided that we wanted a small number of constructs in the
Scheme for our teaching world and that we wanted as much
semantic regularity as possible, including error semantics.

So, if you think of scope as just a way of turning a sequence of
definitions into something that has a textual beginning and end
(okay, that's very rough, but let it go), then you want a construct
that provides a beginning and an end to what otherwise looks
like a sequence of definitions. And we want the same semantics
locally and at top-level.   Following Scheme tradition, we
want this to be an expression, which means we must also add
a body to the construct. So that leaves us with

 (XXXX ( ..... a sequence of definitions .....)
    an-expression)

That's all, and you don't need anything else. Regular syntax, regular
semantics, no need for let, letrec, let*, let+, let-, let& or whatever.

Make life in a beginner course much much simpler.

  http://www.cs.rice.edu/CS/PLT/Teaching/Lectures/Released/Book/node98.htm

Later on, we explain LAMBDA at first  as an abbreviation of  LOCAL:

  (lambda <parameters> <expression>)
  ==
  (local ((define  variable:hygienic <parameters) <expression>))
      variable:hygienic)

'shriram

  (lambda ()
    (define a 7)
    (define b 9)
    ...)

does not preserve the top-level semantics.

  (require-library "macro.ss")

And if you're in DrScheme or DrScheme Jr, which has LOCAL built in,
you need to be in the Intermediate or Advanced Student language
levels:

Welcome to DrScheme Jr version 102/17, Copyright (c) 1995-2000 PLT
Language: Intermediate Student

                                                But I'm wondering why

  http://www.cs.rice.edu/~shriram/311/
  Principles of Programming Languages

Thanks for you patient and thorough explanations.

- does not change the meaning of the program                       [1]

AND

- encapsulates definitions in a more limited scope                 [2]

The (begin (define ...) ...) version certainly meets [1] (trivially,
since it splices the code into the top-level), but it doesn't
accomplish the original purpose, which is to encapsulate the
definitions in a restrictive scope [2], as you yourself observed in an
earlier post.

(define x 3)
(define y 2)
(define z (* x y))
z

evaluates to 6,

  (local ((define x 3)
          (define y 2)
          (define z (* x y)))
   z)

is guaranteed to always evaluate to 6, whereas the value of

  ((lambda ()
     (define x 3)
     (define y 2)
     (define z (* x y))
     z))

is NOT defined -- some implementations will sometimes print 6, while
the same implementation at other times, and other implementations,
will sometimes give an #<undefined> value and at other times give an
error.  In short, you cannot rely on the answer being any particular
thing.  These are all legal responses because this deceptively simple
code, though it looks reasonable enough, is nonsensical!  The reason
for this is subtle; Rob Warnock explained this in a parallel thread
(look for "Differences between SCM version ...").

This is why local is NOT the same as any of these other constructs.
We invented local (a) so we wouldn't have to explain the subtleties
that Warnock explained, and (b) so programmers, having understood the
subtlety, wouldn't have to rewrite their code entirely to work around
the problem.

HTH.

What about:

  ((lambda ()
     (begin
       (define x 3)
       (define y 2)
       (define z (* x y))
       z)))

As R5RS says:

  The <expression>s are evaluated sequentially from left to right, and
  the value(s) of the last <expression> is(are) returned.  This
  expression type is used to sequence side effects such as input and
  output.

So, I would think the above is equivalent to (local ...), as the begin
guarantees that the internal defines are evaluated sequentially.  Or
am I still missing something?

--
Boris Schaefer <bo...@uncommon-sense.net>

Yes, you're still missing something, I'm afraid. Internal definitions
are not themselves "expressions", they're "internal definitions" --
and as such are *exactly* equivalent to a *single* "letrec" expression.
[See R5RS Section 5.2.2 "Internal definitions".] That is, your example
above is *defined* to mean this:

    ((lambda ()
       (begin                   ; now redundant
         (letrec ((x 3)
                  (y 2)
                  (z (* x y)))
           z)))

The "begin" contains only one expression (the "letrec"), and thus there
is no "left to right" sequentiality involved at all.

Oh, and the "letrec" bindings violate the rules [R5RS 4.2.2 & 5.2.2]
requiring that "it must be possible to evaluate each <init> without
assigning or referring to the value of any <variable>"...

-Rob

So apparently 'local' would be a 'primitive expression type' in any
possible R6RS? Or do you have some clever hack for implementing it in
terms of lambda?

  > (local ((define y (+ x 20))
                   (define x 10))
       (* x y))

DrScheme report the following error (Intermediate):

   Variable x referenced before definition or initialization

And at top-level, it's pretty much the same error message.

If I understood how local was usefully different from let* I would
either have another go at it or give up, convinced it was impossible.

I'm sure local would handle syntactic sugar for defining procedures.
This is possible to deal with in an R5RS macro.

I'm sure local will treat subsequent defines of the same variable as
set!, but one might just say "use set! when you want set!" and ignore
this problem.

I know let* suggests nested environment frames and local suggests just
one such frame, but I can't think what other practical implications
there might be besides the set! issue.

That's a pretty significant (and useful) difference.

Yes, but... Letrec *doesn't* provide for sequential assignment like let*,
so what do you do when you need *both*? One answer: Use nested "letrec"s.
But that doesn't provide *mutual* recursion.

Another answer: Use MzScheme's "letrec*-values" (which is not in R5RS, of
course), which is what I'm guessing their "local" maps into at some level:

        In a letrec*-values expression, the scope of the variables
        of each clause includes all of the binding clauses. The clause
        expressions are evaluated and bound to variables sequentially.

-Rob

Ok, I'm convinced it's impossible.  The best I could do would be to take
my previous macro and change the initial values from #f to a procedure
that throws an error, lessening the insidiousness.

(local
 (define ?x ?body)
 ...)
-->
(letrec ((?x ?body)) (local ...))

(local
 (define (?x . ?args) . ?body)
 ...)
-->
(letrec ((?x (lambda ?args . ?body))) (local ...))

(local ...) --> (begin ...)

(let-sequential-and-mutually-recursive-and-perhaps-followed-by-a-star
  ((<variable> <expression>) ...)
  <body>)

[macro-definition left as an exercise to the reader. Oh, BTW perhaps we call
it 'letrec*' ?
Someone will disagree, I'm afraid]

It would *definitely* look better than abusing poor old 'define'.
We have 'let' for a sequence of bindings evaluated quasi-parallel,
'let*' for sequential bindings, 'letrec' for mutual recursive quasi-parallel
bindings, and...

local is useful.  It lets programmers write their code at the
top-level, get it all tested and ship-shape, then toss it into a
restricted context without having to edit the code (and introduce
who-knows-what errors).  There is value in that.

In the same way, the PLT Scheme module ("unit") system lets
programmers define, test and close over a collection of definitions
and expressions, then wrap (unit ...)  around the lot.  That is an
even more useful capability.

In both cases, I do not want to have to modify my code, both on a
matter of principle, and so I can easily extract the code back out of
its restricted context for testing, porting, whatever.  And this is a
*linguistic* solution, not one based on Emacs cruft or whatever.

Now that I think I understand `local' (thanks to the reply of Rob
Warnock to my post), I tend to think that I would prefer a `letrec*'
over `local'.  It really looks much nicer than `local'.

--
Boris Schaefer <bo...@uncommon-sense.net>