www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Static initialization of associative arrays

reply Chris Piker <chris hoopjump.com> writes:
Hi D

At work I've begun writing programs in D that I would typically 
write in python.  My goal is to get away from split python/C 
development and just use one language most of the time.  Today I 
ran across a situation where an immutable associative array would 
be handy. While perusing the language spec I noticed here:

   https://dlang.org/spec/hash-map.html#static_initialization

that this feature is not yet implemented.  So where do I go learn 
about the status of a feature?  I'd like to check on the progress 
of this particular one.  For now I'll use a 'static if' construct 
to ready the array.

As someone with a python background it's nice if I can avoid 
extra lines of code for straight forward ideas, but I understand 
that switching to faster compiled code doesn't come for free and 
some extra boiler-plate will be needed.

By the way I do like that intended features are documented up 
front, even if no one's had time to work on them.

Thanks,
Mar 11 2021
next sibling parent reply =?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
On 3/11/21 10:06 AM, Chris Piker wrote:


    https://dlang.org/spec/hash-map.html#static_initialization

 that this feature is not yet implemented.


I use a shared static this() block:

immutable string[int] aa;

shared static this() {
   aa = [ 1: "one" ];
}

void main() {
   assert(aa.length == 1);
}

And it is possible to build an AA at compile time as the initial value 
but it still needs a trivial assigment to the immutable variable. 
Assuming that we have the following file at compile time named 'my_aa':

--- 8< ---
1 one
2 two
--- 8< ---

And remembering that we have to use the -J switch when compiling (e.g. 
as -J.), you can parse and build an AA from that file like this. (Sorry 
for insisting on the the range style; it can be done in other ways).

immutable string[int] aa;

shared static this() {
   import std.algorithm;
   import std.range;
   import std.typecons;
   import std.conv;

   enum compileTimeAA = import("my_aa")
                        .splitter
                        .chunks(2)
                        .map!(a => tuple(a.front.to!int,
                                         a.dropOne.front))
                        .assocArray;

   aa = compileTimeAA;
}

import std.stdio;

void main() {
   writeln(aa);
}

Ali
Mar 11 2021
next sibling parent Chris Piker <chris hoopjump.com> writes:
On Thursday, 11 March 2021 at 18:41:08 UTC, Ali Çehreli wrote:

 On 3/11/21 10:06 AM, Chris Piker wrote:


    https://dlang.org/spec/hash-map.html#static_initialization

 that this feature is not yet implemented.


 I use a shared static this() block:

 immutable string[int] aa;

 shared static this() {
   aa = [ 1: "one" ];
 }

 Ali


Hi Ali

Always good to hear from an author.  I picked up a copy of your 
book the other day... nice work!

I appreciate the tips on compile-time execution (hadn't thought 
of that), but do you know how I find out about the implementation 
status of a feature in D?  I'm aware of the DIP system, but I 
though DIPs were just for language changes.


Thanks,
Mar 11 2021
prev sibling parent Imperatorn <johan_forsberg_86 hotmail.com> writes:
On Thursday, 11 March 2021 at 18:41:08 UTC, Ali Çehreli wrote:

 On 3/11/21 10:06 AM, Chris Piker wrote:


    https://dlang.org/spec/hash-map.html#static_initialization

 that this feature is not yet implemented.


 I use a shared static this() block:

 immutable string[int] aa;

 shared static this() {
   aa = [ 1: "one" ];
 }

 void main() {
   assert(aa.length == 1);
 }

 And it is possible to build an AA at compile time as the 
 initial value but it still needs a trivial assigment to the 
 immutable variable. Assuming that we have the following file at 
 compile time named 'my_aa':

 --- 8< ---
 1 one
 2 two
 --- 8< ---

 And remembering that we have to use the -J switch when 
 compiling (e.g. as -J.), you can parse and build an AA from 
 that file like this. (Sorry for insisting on the the range 
 style; it can be done in other ways).

 immutable string[int] aa;

 shared static this() {
   import std.algorithm;
   import std.range;
   import std.typecons;
   import std.conv;

   enum compileTimeAA = import("my_aa")
                        .splitter
                        .chunks(2)
                        .map!(a => tuple(a.front.to!int,
                                         a.dropOne.front))
                        .assocArray;

   aa = compileTimeAA;
 }

 import std.stdio;

 void main() {
   writeln(aa);
 }

 Ali


You can however do like this (cheating):
https://run.dlang.io/is/9TSfAB

"The variable myOptions is assigned the result of the literal at 
runtime. But because it's immutable, the compiler knows what's in 
it. So it can extrapolate back to the literal what it is at 
compile time"

We had a discussion in Discord about this last week.
Mar 11 2021
prev sibling parent reply "H. S. Teoh" <hsteoh quickfur.ath.cx> writes:
On Thu, Mar 11, 2021 at 06:06:35PM +0000, Chris Piker via Digitalmars-d-learn
wrote:
[...]

 Today I ran across a situation where an immutable associative array
 would be handy. While perusing the language spec I noticed here:
 
   https://dlang.org/spec/hash-map.html#static_initialization
 
 that this feature is not yet implemented.


[...]

The subsequent section on the linked page gives the solution /
workaround. Just declare your immutable AA without initialization, and
initialize it in a static ctor:

	immutable int[string] aa;
	shared static this() {
		aa = [ "abc": 123, "def": 456, /* ... */ ];
	}


T

-- 
INTEL = Only half of "intelligence".
Mar 11 2021
parent Chris Piker <chris hoopjump.com> writes:
On Thursday, 11 March 2021 at 19:12:34 UTC, H. S. Teoh wrote:

 On Thu, Mar 11, 2021 at 06:06:35PM +0000, Chris Piker via 
 	immutable int[string] aa;
 	shared static this() {
 		aa = [ "abc": 123, "def": 456, /* ... */ ];
 	}


Hi H.S.T

Yes, I'm using static if, but do you know if direct 
implementation of immutable associative array assignment (as 
given on the language spec page) will be implemented at some 
point?

This is not a make-or-break feature that I need, just an 
opportunity to gain meta-information.  The actual problem is easy 
to work around, I'm mostly asking out of curiosity to learn more 
about the D ecosystem and how it functions.

Thanks,
Mar 11 2021