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

Re: various comments

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

Per Bothner writes:

> Jussi Piitulainen wrote:
>> (define arr1 (share-array arr (shape 0 3) (lambda (j) (- 2 j))))
>> Then I get essentially the same array as vec. Its implementation
>> might be more expensive, though, while vec remains oblivious to all
>> that is going on.
> The result arr1 should *not* point to arr, but should just re-use
> the same data vector vec.


> In this case share-array may do a little more work, but the result
> should *not* be any more expensive to use - in fact it should be
> exactly the same, using the same data-vector.

Arrays that share the same backing vector are the same. Just the index
maps are different, and shapes.

But arr1 is a zero-based one-dimensional array whose elements are
exactly the elements of its backing vector in their native order, so
it could as well be just the backing vector, now that we assume
vectors are arrays.

> However, (eq? arr arr1) must be #f.

Oh, but even (equal? arr arr1) must be #f. The question is, will we
accept (eq? vec arr1) as #f when that could be #t. Here vec was R5RS
vector, arr shared it in reverse, and arr1 shared arr in reverse.

The cost of making (eq? vec arr1) #t might not be too high at all.