[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: SRFI-10 syntax vs. #nA syntax
Bradd W. Szonye wrote:
Per Bothner wrote:
In APL, a rank-0 array is the same as a scalar. In Scheme, it would
be difficult to make them the same. One reason is mutability: a
rank-0 array in Scheme and Common Lisp is actually a cell that
contains a mutable value.
That may be true in Common Lisp (I don't know it well enough to judge),
but it's not currently true in RnRS+SRFI Scheme. As far as I know, only
SRFI 47 mentions rank-0 arrays at all, and it uses 0 rank to describe
all non-array values. That's closer to the APL meaning.
Saying that the array-rank function returns 0 for a non-array is very
different from saying that arrays of rank 0 are the same thing as
They are different, for Common Lisp, and any consistent interpretation
of SRFI-47 *or* SRFI-25. See below.
Even thpugh we talking about literals which are upposed to be
immutable, that doesn't solve the problem whether the dereferencing is
automatic or not: a 0-rank mutable array is a cell, which is different
from the value stored in it. I.e. getting its value requires some
kind of array-ref function call. An immutable value is one where
setting is prohibited (undefined), but getting uses the same functions
as for accessing a mutable value. Hence, scalar cannot be equivalent
to a rank-0 array in Scheme, even though it is the same in APL.
Huh? I can't make any sense out of this. Scheme does not /define/ a
rank-0 array as a boxed value; Scheme doesn't define arrays at all. And
the "boxedness" of a rank-0 array cannot be fundamental, since APL
equates rank-0 arrays and scalars.
I don't see how you reach your conclusion (rank-0 arrays aren't scalars
in Scheme) without assuming it as a premise. Why must rank-0 arrays be
boxed values (cells)? That's not self-evident, nor does it seem useful,
especially since APL allegedly works differently.
In APL arrays are immutable. An APL array contains a number of values,
where the number is equal to the product of the dimensions. That means
that a rank-0 array contains 1 value, but since the array is immutable
we can treat the rank-0 array as equivalent to its contained value.
In Scheme (i.e. in SRFI-25 or SRFI-47) and Common Lisp arrays are
mutable. A Scheme array contains a number of "locations" (or
"cells" or "places"), where the number is equal to the product of the
dimensions. Each location contains a value; if the array is mutable
(the normal case) then the contained value may be changed using
array-set! Hence we must distinguish between the location and the
value stored in it. A rank-0 array contains 1 location, which for
consistency must also be mutable (except for literal arrays). Hence,
a rank-0 array is not equivalent to the value stored in its location.