[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
>> I think we should introduce an INTEGER-LENGTH-LIMIT constant which would be
>> the largest value that INTEGER-LENGTH could return.
> Presumably, then we also need a constant called CONS-LIMIT, which is the
> maximum allowable length of any list. After all, someone might want to
> use a list of T's and NIL's instead of a bit vector, and it weakens the
> standard if we don't tell him exactly how long this list can be.
> What we do if someone creates two of these maximum-length lists, or a
> maximum-length list of maximum-length lists, I don't know, but we had
> better decide, since it will weaken the standard if we are vague about
> what is allowed here.
The problem is that that is exactly what the limits DON'T do -- they
don't guarantee that at any given moment the biggest array you can create
is size x. I don't really think the various limits already provided
are worth much. Once in a while they may allow someone to decide
early on that porting a particular application to a particular
implementation is infeasible (because it uses arrays, or whatever, that
are bigger than a limit), but it can never give much assurance that
an application which does respect the limits is portable to a
particular implementation, since at any given moment there may not
be space available to allocate an object, even though it of legal
size for the implementation.
The implementor is left with the problem of deciding what to advertise
as the limits for her particular implementation. What will users
care about? The largest array that can be allocated on an empty
system with maximum memory? The largest array that can be allocated
on an empty system with the smallest memory configuration sold? The
largest array that can be allocated with memory in a "typical"
configuration and already populated with a "typical" amount of
pre-existing stuff? What's typical?
Adding more limits doesn't seem to me to be very useful.
gould/csd - urbana