[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

*To*: scheme@mc.lcs.mit.edu*Subject*: "unspecified" and SET!*From*: Dorai Sitaram <titan!dorai@rice.edu>*Date*: Sun ,18 Jun 89 19:17:50 EDT*Organization*: Rice University, Houston*Sender*: scheme-request@mc.lcs.mit.edu

The recent discussion of "unspecified" values reveals that Scheme is not as syntactically uniform as it is claimed to be. Some Scheme syntactic forms return meaningful values, others don't: the former are "expressions" and the latter "commands". "Commands" are usually used to represent side-effects, e.g., assignment in the form of set!. In an expression-oriented language, a "command" is awkwardly "expressed" by an expression returning an arbitrary "unspecified" value. Perhaps, SET! is not the ideal side-effecting construct for an expression-oriented language. Felleisen and Friedman [1] propose a side-effecting construct called a SIGMA-capability. This looks just like a LAMBDA-expression, but whereas LAMBDA introduces new bound variables, SIGMA modifies the binding of existing lexical variables. In other words, on applying a SIGMA-capability to arguments, the variables corresponding to the SIGMA-parameters are side-effected. Problems about "unspecified" return values disappear. The application of a SIGMA-capability side-effects the SIGMA-parameters and returns the result of evaluating the SIGMA-body (the parallel being the application of a LAMBDA-expression). In addition, SIGMA gives a very natural method for parallel assignment, since the arguments to a SIGMA-capability are all evaluated before the application performs the side-effects. We can retrieve the old SET! from SIGMA as follows: (set! x a) == ((sigma (x) <what-now>) a) where <what-now> is the "unspecified" value of your choice. Thus, there is no dependence on a system-chosen unspecified value. Even better, we need not fall back on a command with its necessarily arbitrary choice of unspecified return value. We can define a _generalized_ SET! in terms of SIGMA that is more along the lines of LET in terms of LAMBDA: (set! ([x a] ...) e ...) == ((sigma (x ...) e ...) a ...) The upshot of all this is that while we have side-effects, we still have a syntactically uniform language. --dorai [1] Felleisen & Friedman, A calculus for assigments ..., POPL 1987, 314 - 325. ps: In terms of SET!, SIGMA's effect is as follows: (sigma (x ...) e ...) == (lambda (x^ ...) (set! x x^) ... e ...) where x^ ... are new variables, used only to show what's going on. A native implementation of SIGMA is simply got by mimicking LAMBDA, except for the following: where LAMBDA has extend-environment, SIGMA has update-environment. ------------------------------------------------------------------------------- It may be that the gulfs will wash us down; It may be we shall touch the Happy Isles. -------------------------------------------------------------------------------

**Follow-Ups**:**"unspecified" and SET!***From:*Alan Bawden <Alan@REAGAN.AI.MIT.EDU>

- Prev by Date:
**BUG IN EXPANDED MEMORY TI PC-SCHEME?** - Next by Date:
**"unspecified" and SET!** - Previous by thread:
**BUG IN EXPANDED MEMORY TI PC-SCHEME?** - Next by thread:
**"unspecified" and SET!** - Index(es):