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

Re: SRFI-10 syntax vs. #nA syntax

This page is part of the web mail archives of SRFI 58 from before July 7th, 2015. The new archives for SRFI 58 contain all messages, not just those from before July 7th, 2015.

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.
	--Per Bothner
per@xxxxxxxxxxx   http://per.bothner.com/