I want to create a global immutable associative array and have it be accessible from anywhere at compile-time.  How can I do that?

With:
immutable int[int] aa = [1:2,3:4];

I get:
source/thing.d(1): Error: non-constant expression [1:2, 3:4]

And with:
immutable int[int] aa;

static this(){
	aa = [1:2,3:4];
}

int c = aa[3];

I get:
source/thing.d(7): Error: static variable aa cannot be read at compile time

Also associative arrays don't seem to have a .idup

Is there any other way to do this?

On Wednesday, 19 March 2014 at 00:16:31 UTC, dnspies wrote:
> I want to create a global immutable associative array and have it be accessible from anywhere at compile-time.  How can I do that?
>
> With:
> immutable int[int] aa = [1:2,3:4];
>
> I get:
> source/thing.d(1): Error: non-constant expression [1:2, 3:4]
>
> And with:
> immutable int[int] aa;
>
> static this(){
> 	aa = [1:2,3:4];
> }
>
> int c = aa[3];
>
> I get:
> source/thing.d(7): Error: static variable aa cannot be read at compile time
>
> Also associative arrays don't seem to have a .idup
>
> Is there any other way to do this?


You just have to construct it first and then claim that it is unique and so safely cast it to immutable:


import std.exception : assumeUnique;

immutable int[int] aa;

static this(){
   auto temp = [1:2, 3:4];
   aa = assumeUnique(temp);
}

dnspies:

> I want to create a global immutable associative array and have it be accessible from anywhere at compile-time.  How can I do that?
>
> With:
> immutable int[int] aa = [1:2,3:4];
>
> I get:
> source/thing.d(1): Error: non-constant expression [1:2, 3:4]
>
> And with:
> immutable int[int] aa;
>
> static this(){
> 	aa = [1:2,3:4];
> }
>
> int c = aa[3];
>
> I get:
> source/thing.d(7): Error: static variable aa cannot be read at compile time


immutable int[int] aa;
pure static this() {
    aa = [1: 2, 3: 4];
}
void main() {
    int c = aa[3];
}


Bye,
bearophile

> You just have to construct it first and then claim that it is unique and so safely cast it to immutable:
>
>
> import std.exception : assumeUnique;
>
> immutable int[int] aa;
>
> static this(){
>    auto temp = [1:2, 3:4];
>    aa = assumeUnique(temp);
> }

Seems unintuitive and roundabout. Is this a bug or a feature?

Dan Killebrew:

> Seems unintuitive and roundabout. Is this a bug or a feature?

It's a good feature. Generally immutable variables are initializable from strongly pure functions. If you think about what immutability and purity mean, it's a good match.

Bye,
bearophile

On Wednesday, 19 March 2014 at 00:37:27 UTC, bearophile wrote:
> Dan Killebrew:
>
>> Seems unintuitive and roundabout. Is this a bug or a feature?
>
> It's a good feature. Generally immutable variables are initializable from strongly pure functions. If you think about what immutability and purity mean, it's a good match.
>
> Bye,
> bearophile

I meant something else. Why doesn't this work:

immutable int[int] aa = [1:2,3:4];

Seems like it should work to me. After all, this works:

immutable int[] a = [1,2,3,4];

So how is the second 'more constant' than the first? The fact that the first code block does not compile seems like a bug.

Dan Killebrew:

> I meant something else. Why doesn't this work:
>
> immutable int[int] aa = [1:2,3:4];
>
> Seems like it should work to me. After all, this works:
>
> immutable int[] a = [1,2,3,4];
>
> So how is the second 'more constant' than the first? The fact that the first code block does not compile seems like a bug.

If you meant defining directly the global associative arrays, it's a compiler/runtime limitation that will be removed. It's in Bugzilla since years.

Bye,
bearophile

On Wednesday, 19 March 2014 at 00:16:31 UTC, dnspies wrote:
> I want to create a global immutable associative array and have it be accessible from anywhere at compile-time.  How can I do that?
>
> With:
> immutable int[int] aa = [1:2,3:4];
>
> I get:
> source/thing.d(1): Error: non-constant expression [1:2, 3:4]
>
> And with:
> immutable int[int] aa;
>
> static this(){
> 	aa = [1:2,3:4];
> }
>
> int c = aa[3];
>
> I get:
> source/thing.d(7): Error: static variable aa cannot be read at compile time
>
> Also associative arrays don't seem to have a .idup
>
> Is there any other way to do this?

Is an enum not appropriate? Because it can be used to push constants and available at ctfe.

enum int[int] aa = [1: 2, 3: 4];
pragma(msg, aa);

Rikki Cattermole:

> Is an enum not appropriate? Because it can be used to push constants and available at ctfe.
>
> enum int[int] aa = [1: 2, 3: 4];
> pragma(msg, aa);

This is bad from an efficiency point of view. I think Don even suggested to disallow it.

Bye,
bearophile

On Wednesday, 19 March 2014 at 01:56:35 UTC, Rikki Cattermole wrote:
> Is an enum not appropriate? Because it can be used to push constants and available at ctfe.
>
> enum int[int] aa = [1: 2, 3: 4];
> pragma(msg, aa);

This will create a new associative array at runtime wherever aa is used, rather than creating only one instance at compile time and referring to it wherever aa is used. This is also the case with normal arrays, and possibly objects... I can't remember.