I find myself writing the following a lot:

  a[base..base+width]

to get the slice starting at 'base' of width 'width'. In verilog, we select members of a vector/array in three ways

  a[c :  d]   //D: a[c   .. d+1]
  a[c +: d]   //D: a[c   .. c+d]
  a[c -: d]   //D: a[c-d .. c]

Borrowing a bit from verilog, could we make two new operators, maybe +.. and -.. that allow us to do the same?

I could then write e.g.

  a[base+..width]

instead of the more verbose

  a[base..base+width]

>   a[c -: d]   //D: a[c-d .. c]

I think this should be

a[c -: d]   //D: a[c-d+1 .. c+1],  e.g. a[5 -: 2] == [a[4], a[5]]

On Sunday, 8 September 2013 at 10:53:23 UTC, Øivind wrote:
>
>>  a[c -: d]   //D: a[c-d .. c]
>
> I think this should be
>
> a[c -: d]   //D: a[c-d+1 .. c+1],  e.g. a[5 -: 2] == [a[4], a[5]]


try &a[base][0..width]

On 2013-09-08, 14:02, Chang Long wrote:

> On Sunday, 8 September 2013 at 10:53:23 UTC, Øivind wrote:
>>
>>>  a[c -: d]   //D: a[c-d .. c]
>>
>> I think this should be
>>
>> a[c -: d]   //D: a[c-d+1 .. c+1],  e.g. a[5 -: 2] == [a[4], a[5]]
>
>
> try &a[base][0..width]

That throws safety out the window for one. If you want safety and
no new language features, this should work:

  a[base..$][0..width]

-- 
  Simen

On Sunday, 8 September 2013 at 12:08:50 UTC, Simen Kjaeraas wrote:
> On 2013-09-08, 14:02, Chang Long wrote:
>
>> On Sunday, 8 September 2013 at 10:53:23 UTC, Øivind wrote:
>>>
>>>> a[c -: d]   //D: a[c-d .. c]
>>>
>>> I think this should be
>>>
>>> a[c -: d]   //D: a[c-d+1 .. c+1],  e.g. a[5 -: 2] == [a[4], a[5]]
>>
>>
>> try &a[base][0..width]
>
> That throws safety out the window for one. If you want safety and
> no new language features, this should work:
>
>   a[base..$][0..width]

Thanks

Still a little verbose, but at least you don't have to type the same things twice.

I guess the double slice will be optimized into a single one at least for release mode, so there should be no performance degredation?

On 9/8/2013 6:03 AM, "Øivind" wrote:
>> That throws safety out the window for one. If you want safety and
>> no new language features, this should work:
>>
>>   a[base..$][0..width]
>
> Thanks
>
> Still a little verbose, but at least you don't have to type the same things twice.
>
> I guess the double slice will be optimized into a single one at least for
> release mode, so there should be no performance degredation?


Try it and see. If it isn't, feel free to file an enhancement request for the optimizer!