Idiomatic way to process const/immutable arrays as ranges

[Regan Heath]

On Mon, 11 Feb 2013 17:13:21 -0000, Dicebot <m.strashun at gmail.com> wrote:

> On Monday, 11 February 2013 at 16:54:04 UTC, Jonathan M Davis wrote:
>> The const(T)[] cannot alter the original array at all, so I concur with  
>> Steven
>> in that the complaints about not wanting to use tail-const make no  
>> sense.
>> Maybe this article will help clear things up:
>
> And I exactly want to prohibit altering original array. What I want is  
> to copy slice (without deep copying of data) and alter this fresh copy.  
> I can't see how it contradicts immutability guarantees or D array design.

This *does* prohibit altering the original array ("test" passed by main  
below) without deep copying the data, and allows you to alter the fresh  
copy ("arr" inside the function).

Example:

import std.stdio;

void foo(const(string)[] arr)
{
   // arr[0] = "aa";  // Error: arr[0] isn't mutable
   arr.length = 10;
   writefln("foo arr.length = %d", arr.length);
}

void main()
{
   const(string[]) test = ["a", "b"];

   // test[0] = "aa";   // Error: test[0] isn't mutable
   // test.length = 10; // Error: variable ****.test cannot modify const
   foo(test);
   writefln("test.length = %d", test.length);
}

What you have to realise is that when you pass an array/slice in D, you  
get a copy of that array/slice in the function.  Just like when you pass  
an 'int' or any other "value" type.

Think of the array/slice as this struct:

struct array
{
   int length;
   void *ptr;
}

Passing that to a function would copy the entire struct into the function  
parameter, altering that parameter would not alter the original.   
array/slices are the same.

The data referred to by 'ptr' is not copied, and neither are the elements  
of an array/slice.

If you did want to alter the original, you'd pass the array/slice by  
'ref'erence.

R

-- 
Using Opera's revolutionary email client: http://www.opera.com/mail/