Another question regarding arrays, this time associative arrays.

int[char[]] months = ["Jan" : 1, "Feb" : 2,

etc. definitely doesn't work as intended, that is supplying a initializing set of keys and values.

Does D currently support an initialization syntax for associative arrays?

Thanks,
Joe

Joseph Bell wrote:
> Does D currently support an initialization syntax for associative arrays?

No, that's one of the big missing things.

Frits van Bommel wrote:
> No, that's one of the big missing things.

Exactly!

-- 
serg.

Serg Kovrov wrote:
> Frits van Bommel wrote:
>> No, that's one of the big missing things.
> 
> Exactly!
> 

Seems like with tuples now it might be possible to make a function that would do the trick:

int[char[]] months = AA("Jan", 1, "Feb", 2, "Mar", 3);

This could be another interesting challenge akin to Andrei's max() challenge.  Write a function that constructs an AA from it's arguments using the "best" types.

For that matter it would be interesting to see a template which constructs an array using the best type to hold the arguments (as opposed to just the type of the first argument).

--bb

Certainly, anything is possible, but honestly, its a headache.  Is there a specific forum or tracking mechanism to monitor or provide input on language feature requests?  From the previous posts to this thread it seems this one would be a candidate for a subsequent revision.

Joe

Bill Baxter wrote:
> Serg Kovrov wrote:
>> Frits van Bommel wrote:
>>> No, that's one of the big missing things.
>>
>> Exactly!
>>
> 
> Seems like with tuples now it might be possible to make a function that would do the trick:
> 
> int[char[]] months = AA("Jan", 1, "Feb", 2, "Mar", 3);
> 
> This could be another interesting challenge akin to Andrei's max() challenge.  Write a function that constructs an AA from it's arguments using the "best" types.
> 
> For that matter it would be interesting to see a template which constructs an array using the best type to hold the arguments (as opposed to just the type of the first argument).
> 
> --bb

Bill Baxter wrote:
> Serg Kovrov wrote:
>> Frits van Bommel wrote:
>>> No, that's one of the big missing things.
>>
>> Exactly!
>>
> 
> Seems like with tuples now it might be possible to make a function that would do the trick:
> 
> int[char[]] months = AA("Jan", 1, "Feb", 2, "Mar", 3);
> 
> This could be another interesting challenge akin to Andrei's max() challenge.  Write a function that constructs an AA from it's arguments using the "best" types.
> 
> For that matter it would be interesting to see a template which constructs an array using the best type to hold the arguments (as opposed to just the type of the first argument).
> 
> --bb

I actually have an Assoc! template in Cashew for this, except the syntax is:
int[char[]] months = Assoc!(
  ["Jan", "Feb", "Mar"],
  [1    , 2    , 3    ]
);

Your "inline" means might be better, though, now that we have Tuples.

Also, for the moment, the "workaround" is to initialize the associative array in a module constructor.  I would love to see this fixed ASAP.  (Feels like such a sore spot.)

-- Chris Nicholson-Sauls

Joseph Bell wrote:
> 
> Certainly, anything is possible, but honestly, its a headache.  Is there a specific forum or tracking mechanism to monitor or provide input on language feature requests?  From the previous posts to this thread it seems this one would be a candidate for a subsequent revision.

Yep.  There's a bugzilla:
  http://d.puremagic.com/issues/

I'd bet that a request for an assoc array  literal syntax is already in there.

--bb

Bill Baxter wrote:
> Serg Kovrov wrote:
>> Frits van Bommel wrote:
>>> No, that's one of the big missing things.
>>
>> Exactly!
>>
> 
> Seems like with tuples now it might be possible to make a function that would do the trick:
> 
> int[char[]] months = AA("Jan", 1, "Feb", 2, "Mar", 3);
> 
> This could be another interesting challenge akin to Andrei's max() challenge.  Write a function that constructs an AA from it's arguments using the "best" types.
> 
> For that matter it would be interesting to see a template which constructs an array using the best type to hold the arguments (as opposed to just the type of the first argument).
> 
> --bb

I don't know why all this syntax is needed; in particular, without the a.dup, it crashes.  I don't know why -- it might be a bug or just a bad assumption on my part.

// -*- c++ -*-

import std.stdio;
import std.string;
import std.traits;

template AA_types(E...) {
    static if(isStaticArray!(typeof(E[0]))) {
        alias typeof(E[0].init)[] AA_key;
        alias typeof(E[1])        AA_value;
        alias AA_value[AA_key]    AA_type;
    } else {
        alias typeof(E[0])     AA_key;
        alias typeof(E[1])     AA_value;
        alias AA_value[AA_key] AA_type;
    }

}

AA_types!(E).AA_type AA(E...)(E values)
{
    static assert(values.length);
    static assert((values.length % 2) == 0);

    alias AA_types!(E).AA_key   TKey;
    alias AA_types!(E).AA_value TValue;
    alias AA_types!(E).AA_type  TArray;

    TKey   K;
    TArray rv;

    foreach(i, a; values) {
        static if ((i & 1) == 0) {
            static if (is(typeof(a.length))) {
                K = a.dup;
            } else {
                K = a;
            }
        }
        static if ((i & 1) == 1) {
            rv[K] = a;
        }
    }


    return rv;
}

int main(char[][] args)
{
    auto f = AA("run", 2, "the", 1, "you long", 4);

    foreach(i, a; f) {
        writefln("%s -> %s", i, a);
    }

    return 0;
}

Kevin Bealer wrote:
> Bill Baxter wrote:
>> Serg Kovrov wrote:
>>> Frits van Bommel wrote:
>>>> No, that's one of the big missing things.
>>>
>>> Exactly!
>>>
>>
>> Seems like with tuples now it might be possible to make a function that would do the trick:
>>
>> int[char[]] months = AA("Jan", 1, "Feb", 2, "Mar", 3);
>>
>> This could be another interesting challenge akin to Andrei's max() challenge.  Write a function that constructs an AA from it's arguments using the "best" types.
>>
>> For that matter it would be interesting to see a template which constructs an array using the best type to hold the arguments (as opposed to just the type of the first argument).
>>
>> --bb
> 
> I don't know why all this syntax is needed; in particular, without the a.dup, it crashes.  I don't know why -- it might be a bug or just a bad assumption on my part.

make it 'inout a', maybe?

--bb

Bill Baxter wrote:
> Kevin Bealer wrote:
>> Bill Baxter wrote:
>>> Serg Kovrov wrote:
>>>> Frits van Bommel wrote:
>>>>> No, that's one of the big missing things.
>>>>
>>>> Exactly!
>>>>
>>>
>>> Seems like with tuples now it might be possible to make a function that would do the trick:
>>>
>>> int[char[]] months = AA("Jan", 1, "Feb", 2, "Mar", 3);
>>>
>>> This could be another interesting challenge akin to Andrei's max() challenge.  Write a function that constructs an AA from it's arguments using the "best" types.
>>>
>>> For that matter it would be interesting to see a template which constructs an array using the best type to hold the arguments (as opposed to just the type of the first argument).
>>>
>>> --bb
>>
>> I don't know why all this syntax is needed; in particular, without the a.dup, it crashes.  I don't know why -- it might be a bug or just a bad assumption on my part.
> 
> make it 'inout a', maybe?
> 
> --bb

I haven't checked to see whether that works - but even if it does, I still don't see *why* it's more legal.

Kevin