From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on
	ip-172-31-65-14.ec2.internal
X-Spam-Level: 
X-Spam-Status: No, score=-1.9 required=3.0 tests=BAYES_00,T_SCC_BODY_TEXT_LINE
	autolearn=ham autolearn_force=no version=3.4.6
Path: eternal-september.org!reader01.eternal-september.org!reader02.eternal-september.org!aioe.org!gz+JwLUglqIuIsOsQSSzqA.user.46.165.242.91.POSTED!not-for-mail
From: "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>
Newsgroups: comp.lang.ada
Subject: Re: New aggregates with Ada 2022.
Date: Tue, 28 Jun 2022 09:52:11 +0200
Organization: Aioe.org NNTP Server
Message-ID: <t9ebvc$1amt$1@gioia.aioe.org>
References: <t8ml0l$1vo2$1@gioia.aioe.org> <t8qptm$gof$2@dont-email.me>
 <t8qrmo$p79$1@gioia.aioe.org> <t8tk6i$ue6$1@dont-email.me>
 <t8ulu9$jca$1@gioia.aioe.org> <t90ebe$nve$1@dont-email.me>
 <t91buq$10im$1@gioia.aioe.org> <t933oh$o2o$1@dont-email.me>
 <t93mr6$pvm$1@gioia.aioe.org> <t95uha$edq$1@dont-email.me>
 <t96i9f$1mc1$1@gioia.aioe.org> <t9d7u5$ogle$1@dont-email.me>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="43741"; posting-host="gz+JwLUglqIuIsOsQSSzqA.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
 Thunderbird/91.10.0
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
Xref: reader02.eternal-september.org comp.lang.ada:64039
List-Id: <comp.lang.ada>

On 2022-06-27 23:37, Randy Brukardt wrote:

> The distributed overhead that they cause is
> immense (for instance, you can't have a discontigious array represesentation
> with slices, unless you are willing to pay a substantial cost for *every*
> array parameter). They're the anti-abstraction feature.

There is nothing wrong with having non-contiguous slices of 
non-contiguous arrays! Contiguity of index does not automatically imply 
contiguity of element allocation, unless specifically required by the 
[sub]type constraint.

1D array abstraction is a mapping index -> element where

1. Index has an order. Index has operations 'Succ and 'Pred;

2. The mapping is convex. If there are elements for two indices, then 
there are elements for all indices between them.

Contiguity is a representation constraint.

One should be able to have an array equivalent of unbounded string with 
unbounded slices both allocated non-contiguously. The slices you could 
shrink or expand:

    Text (45..80) := "";  -- Cut a piece off

At the same time one should have a contiguous subtype of the same 
unbounded string for interfacing purposes, dealt by copy-out copy-in.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de