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

[no subject]

 from: brown@DEC-HUDSON
     The main thing I think is that the subset should be a true subset;
     i.e. a program that is written purely in the subset is gaurenteed
     to work in an implementation of full language.  I believe this
     requires that the subset be lexically scoped.
[I disagree with that conclusion. There are several ways that one LISP
 can be a subset of another: (1) it can be missing some of the functions,
 (2) it can be missing some of the datatypes, (3) some of the functions
 can know about and be able to handle fewer of the kinds of situations,
 be less flexible, have fewer options, (4) some of the overall mechanisms
 can be less capable.

These are mostly but not totally orthogonal. ACOSH and ASINH can be missing
 even if floating point and complex values are available, thus having
 the datatype doesn't imply all the functions to handle it are around.
 The converse, ASINH and ACOSH are available but they don't handle floating
 point, is probably impossible in CL. Thus they are orthogonal in one
 direction. Ratios might not be implemented, which would mean that READ
 would have to bomb out if it encountered the syntax for a ratio, and
 division of integers couldn't be implemented in all cases either. Thus
 there is some linkage between datatypes available and case that READ and
 / are equipped to handle. Finally, to rebut the assertion claimed above,
 a subset of CL might not have lexical closures implemented and might work
 correctly only on programs that have no undeclared free variables, it might
 even have no optional or rest arguments. A program written in this restricted
 subset would work fine in full blown CL, with identical semantics. Thus a
 subset needn't have lexical scoping. -- For the mathematicians, the null
 language that has no functions and no datatypes, is a subset of CL, and
 is an obvious counterexample to the claim that any subset of CL must have
 lexical scoping. But I think there could be reasonable non-null subsets that
 are easy to implement on small machines or to define in existing systems
 such as PSL, which don't have lexical scoping yet are true subsets.

I think we should be aware of the several dimensions of subsetting, some
 of which I listed above, and consider all those dimensions when defining
 a subset, not just what functions are defined. When we define a subset,
 we should clearly document what functions aren't there at all, what functions
 are implemented in lesser ways, what datatypes are missing, what features
 of general code writing are missing (implicit PROGNs, lexical closures, ...),
 any other differences. Alternately for really drastic subsets just say what
 the subset is and indicate explicitly in the rare cases when the fullblown
 version of some function is defined.  Anyone agree or disagree or amend?]