Return to the
comp.compilers page.
Search the
comp.compilers archives again.
| Related articles |
|---|
| [2 earlier articles] |
| Re: another C-like language? was Compilers :) stephenjohnlimb@gmail.com (Steve Limb) (2023-01-03) |
| Re: another C-like language? was Compilers :) marblypup@yahoo.co.uk (marb...@yahoo.co.uk) (2023-01-05) |
| Re: another C-like language? was Compilers :) david.brown@hesbynett.no (David Brown) (2023-01-06) |
| Re: another C-like language? was Compilers :) 864-117-4973@kylheku.com (Kaz Kylheku) (2023-01-09) |
| Re: another C-like language? was Compilers :) david.brown@hesbynett.no (David Brown) (2023-01-10) |
| Re: another C-like language? was Compilers :) 864-117-4973@kylheku.com (Kaz Kylheku) (2023-01-11) |
| Re: Scheme is not another C-like language? was Compilers :) gneuner2@comcast.net (George Neuner) (2023-01-12) |
| Re: Scheme is not another C-like language? was Compilers :) nmh@t3x.org (Nils M Holm) (2023-01-12) |
| From: | George Neuner <gneuner2@comcast.net> |
| Newsgroups: | comp.compilers |
| Date: | Thu, 12 Jan 2023 02:54:37 -0500 |
| Organization: | A noiseless patient Spider |
| References: | 23-01-001 23-01-002 23-01-003 23-01-008 23-01-016 23-01-029 23-01-033 23-01-038 |
| Injection-Info: | gal.iecc.com; posting-host="news.iecc.com:2001:470:1f07:1126:0:676f:7373:6970"; logging-data="12037"; mail-complaints-to="abuse@iecc.com" |
| Keywords: | Scheme |
| Posted-Date: | 12 Jan 2023 13:38:52 EST |
On Wed, 11 Jan 2023 11:02:56 -0000 (UTC), Kaz Kylheku
<864-117-4973@kylheku.com> wrote:
>It seems that Scheme, with its ugly (define ...) that can be used inside
>block scopes, [disallows name redefinition]!
Agree it's ugly: I never use internal defines in my own code.
Unfortunately some people love them.
>I tried (lambda () (define x 42) (define x 43)) in a Scheme
>implementation and got an error about the duplicate variable.
>
>That's completely silly since it breaks the idea that the block scoped
>define can just be desugared to nested lets.
Unfortunately the experience varies by version:
From R3RS to R5RS, a series of internal defines is treated AS IF they
all are part of a single 'letrec' with the scope being the whole body.
'letrec', of course, does not permit multiple bindings to the same
name.
In R6RS and R7RS, a series of internal defines is treated as a
'letrec*' [note trailing *]. letrec* is equivalent to nested letrec
and so does permit rebinding to the same name ... which will shadow
any previous bindings.
from R5RS 5.2.2 Internal Definitions
... The variable defined by an internal defnition is local to the
body. That is, variable is bound rather than assigned, and the region
of the binding is the entire body. For example,
(let ((x 5))
(define foo (lambda (y) (bar x y)))
(define bar (lambda (a b) (+ (* a b) a)))
(foo (+ x 3))) => 45
A body containing internal definitions can always be converted into a
completely equivalent letrec expression. For example, the let
expression in the above example is equivalent to
(let ((x 5))
(letrec ((foo (lambda (y) (bar x y)))
(bar (lambda (a b) (+ (* a b) a))))
(foo (+ x 3))))
Just as for the equivalent letrec expression, it must be possible to
evaluate each expression of every internal definition in a body
without assigning or referring to the value of any variable being
defined.
From R6RS 11.3 Bodies
The <body> of a lambda, let, let*, let-values, let*-values, letrec, or
letrec* expression, or that of a definition with a body consists of
zero or more definitions followed by one or more expressions.
<definition> ... <expression1> <expression2> ...
Each identifier defined by a definition is local to the <body>. That
is, the identifier is bound, and the region of the binding is the
entire <body> (see section [5.2]).
Example:
(let ((x 5))
(define foo (lambda (y) (bar x y)))
(define bar (lambda (a b) (+ (* a b) a)))
(foo (+ x 3))) => 45
When begin, let-syntax, or letrec-syntax forms occur in a body prior
to the first expression, they are spliced into the body; see
section [11.4.7]. Some or all of the body, including portions wrapped
in begin, let-syntax, or letrec-syntax forms, may be specified by a
macro use (see section [9.2]).
An expanded <body> (see chapter [10]) containing variable definitions
can always be converted into an equivalent letrec* expression. For
example, the let expression in the above example is equivalent to
(let ((x 5))
(letrec* ((foo (lambda (y) (bar x y)))
(bar (lambda (a b) (+ (\* a b) a))))
(foo (+ x 3))))
Return to the
comp.compilers page.
Search the
comp.compilers archives again.