In the following code, I explicitly declare array as immutable. But it compiles with the error shown below in the comment. The array object is declared immutable, so how can the compiler say it is a mutable object? In summary, how to pass an immutable array to an immutable constructor?

class C {
  int i;
  this(immutable int[] array) immutable {
    i = array[0];
  }
}

void func() {
  immutable int[] array = [1];
  auto c = new C(array); // Error: immutable method C.this is not callable using a mutable object
}

On Thursday, 17 March 2016 at 09:57:37 UTC, Jeff Thompson wrote:
> In the following code, I explicitly declare array as immutable. But it compiles with the error shown below in the comment. The array object is declared immutable, so how can the compiler say it is a mutable object? In summary, how to pass an immutable array to an immutable constructor?
>
> class C {
>   int i;
>   this(immutable int[] array) immutable {
>     i = array[0];
>   }
> }
>
> void func() {
>   immutable int[] array = [1];
>   auto c = new C(array); // Error: immutable method C.this is not callable using a mutable object
> }

The error message isn't very good, but remove immutable from the constructor and it works.
>   this(immutable int[] array) {

On Thursday, 17 March 2016 at 10:04:53 UTC, Anonymouse wrote:
> On Thursday, 17 March 2016 at 09:57:37 UTC, Jeff Thompson wrote:
>> In the following code, I explicitly declare array as immutable. But it compiles with the error shown below in the comment. The array object is declared immutable, so how can the compiler say it is a mutable object? In summary, how to pass an immutable array to an immutable constructor?
>>
>> class C {
>>   int i;
>>   this(immutable int[] array) immutable {
>>     i = array[0];
>>   }
>> }
>>
>> void func() {
>>   immutable int[] array = [1];
>>   auto c = new C(array); // Error: immutable method C.this is not callable using a mutable object
>> }
>
> The error message isn't very good, but remove immutable from the constructor and it works.
>>   this(immutable int[] array) {

This is a simplified example from a larger class I have where I need an immutable constructor. This is because I need to construct an object an pass it to other functions which take an immutable object. So, how to keep an immutable constructor?

On Thursday, 17 March 2016 at 10:11:43 UTC, Jeff Thompson wrote:
> This is a simplified example from a larger class I have where I need an immutable constructor. This is because I need to construct an object an pass it to other functions which take an immutable object. So, how to keep an immutable constructor?

The "mutable object" the compiler is complaining about is the instance of C being constructed, not the array.

Change `new C(array)` to `new immutable(C)(array)` and it should work.

On Thursday, 17 March 2016 at 10:11:43 UTC, Jeff Thompson wrote:
> This is a simplified example from a larger class I have where I need an immutable constructor. This is because I need to construct an object an pass it to other functions which take an immutable object. So, how to keep an immutable constructor?

In that case, new immutable C() should work I believe. Also, if you mark the constructor as pure, new C() should be implicitly convertible to an immutable C.

On Thursday, 17 March 2016 at 11:27:01 UTC, Rene Zwanenburg wrote:
> Also, if you mark the constructor as pure, new C() should be implicitly convertible to an immutable C.

Ah! That's a good tip. Now I understand why I never have to say `new immutable(C)()` in my own code. (I am in the habit of marking everything I can as `pure`.)

On Thursday, 17 March 2016 at 11:27:01 UTC, Rene Zwanenburg wrote:
> On Thursday, 17 March 2016 at 10:11:43 UTC, Jeff Thompson wrote:
>> This is a simplified example from a larger class I have where I need an immutable constructor. This is because I need to construct an object an pass it to other functions which take an immutable object. So, how to keep an immutable constructor?
>
> In that case, new immutable C() should work I believe. Also, if you mark the constructor as pure, new C() should be implicitly convertible to an immutable C.

new immutable C() worked! Thanks for the insight.

On 03/17/2016 09:32 AM, Jeff Thompson wrote:
> On Thursday, 17 March 2016 at 11:27:01 UTC, Rene Zwanenburg wrote:
>> On Thursday, 17 March 2016 at 10:11:43 UTC, Jeff Thompson wrote:
>>> This is a simplified example from a larger class I have where I need
>>> an immutable constructor. This is because I need to construct an
>>> object an pass it to other functions which take an immutable object.
>>> So, how to keep an immutable constructor?
>>
>> In that case, new immutable C() should work I believe. Also, if you
>> mark the constructor as pure, new C() should be implicitly convertible
>> to an immutable C.
>
> new immutable C() worked! Thanks for the insight.

In case it's useful to others, I have qualified constructors covered at the following link (without the compilation error that you've faced but still pointing out the fact that the mutable constructor may be called unintentionally):


http://ddili.org/ders/d.en/special_functions.html#ix_special_functions.qualifier,%20constructor

Ali