does things like [1000...2000]

but then lists the values as [0], [1], ...

Could it use the absolute values [1000], [1001], etc?

That way one doesn't have to do mental arithmetic?

Obviously not difficult but I see no reason to not do it.

On Tuesday, 17 September 2019 at 13:48:33 UTC, Brett wrote:
> does things like [1000...2000]
>
> but then lists the values as [0], [1], ...
>
> Could it use the absolute values [1000], [1001], etc?
>
> That way one doesn't have to do mental arithmetic?
>
> Obviously not difficult but I see no reason to not do it.

Also, can AA arrays have their keys sorted? Lexicographical should work. I see no reason not to sort them, specially when the keys are integers, helps locate values in large arrays much easier.

On Tuesday, 17 September 2019 at 17:19:22 UTC, Brett wrote:
> On Tuesday, 17 September 2019 at 13:48:33 UTC, Brett wrote:
>> does things like [1000...2000]
>>
>> but then lists the values as [0], [1], ...
>>
>> Could it use the absolute values [1000], [1001], etc?
>>
>> That way one doesn't have to do mental arithmetic?
>>
>> Obviously not difficult but I see no reason to not do it.
>
> Also, can AA arrays have their keys sorted? Lexicographical should work. I see no reason not to sort them, specially when the keys are integers, helps locate values in large arrays much easier.

And maybe add a linear index on AA's so it is easier to locate values(and/or show length).

On 17/09/2019 22:04, Brett wrote:
> On Tuesday, 17 September 2019 at 17:19:22 UTC, Brett wrote:
>> On Tuesday, 17 September 2019 at 13:48:33 UTC, Brett wrote:
>>> does things like [1000...2000]
>>>
>>> but then lists the values as [0], [1], ...
>>>
>>> Could it use the absolute values [1000], [1001], etc?
>>>
>>> That way one doesn't have to do mental arithmetic?
>>>
>>> Obviously not difficult but I see no reason to not do it.

The nice thing about the current implementation is that there is no extra state but the expression to be passed around by the evaluation (a[1001] == a[1000..2000][1]), but I agree that it is a bit confusing. Maybe there is some other solution...

>>
>> Also, can AA arrays have their keys sorted? Lexicographical should work. I see no reason not to sort them, specially when the keys are integers, helps locate values in large arrays much easier.

This can be a bit expensive for large arrays as all elements need to be read and cached before displaying the first. This is usually done incrementally by the debugger.

> 
> And maybe add a linear index on AA's so it is easier to locate
> values(and/or show length).
> 

This would be easier, but probably not so interesting if not also sorted.

On Friday, 20 September 2019 at 07:27:51 UTC, Rainer Schuetze wrote:
>
>
> On 17/09/2019 22:04, Brett wrote:
>> On Tuesday, 17 September 2019 at 17:19:22 UTC, Brett wrote:
>>> On Tuesday, 17 September 2019 at 13:48:33 UTC, Brett wrote:
>>>> does things like [1000...2000]
>>>>
>>>> but then lists the values as [0], [1], ...
>>>>
>>>> Could it use the absolute values [1000], [1001], etc?
>>>>
>>>> That way one doesn't have to do mental arithmetic?
>>>>
>>>> Obviously not difficult but I see no reason to not do it.
>
> The nice thing about the current implementation is that there is no extra state but the expression to be passed around by the evaluation (a[1001] == a[1000..2000][1]), but I agree that it is a bit confusing. Maybe there is some other solution...
>
>>>
>>> Also, can AA arrays have their keys sorted? Lexicographical should work. I see no reason not to sort them, specially when the keys are integers, helps locate values in large arrays much easier.
>
> This can be a bit expensive for large arrays as all elements need to be read and cached before displaying the first. This is usually done incrementally by the debugger.
>

True. Could have a maximum setting, say, 1000 or 10000. Usually if the array is large one isn't going to look at it much anyways so the worst case is also the rarest.

>> 
>> And maybe add a linear index on AA's so it is easier to locate
>> values(and/or show length).
>> 
>
> This would be easier, but probably not so interesting if not also sorted.

Right, but it helps with locating the index in a large array.. e.g., what is the 245th value. Well, now one has to count but if the index was next to it(or a mouse over could show it) then it would be instant.

It might not help in most cases though but in my particular case it helps since keys are indexes too.

It could be optional to show it and if sorting is added then it would just work hand and hand.