http://d.puremagic.com/issues/show_bug.cgi?id=1597

           Summary: It is not possible to specialize template on associative
                    array.
           Product: D
           Version: 1.022
          Platform: All
        OS/Version: All
            Status: NEW
          Severity: enhancement
          Priority: P2
         Component: DMD
        AssignedTo: bugzilla@digitalmars.com
        ReportedBy: aarti@interia.pl


void parse(T)() {
}

//What to write here???
void parse(T : ?????)() {
}

void main() {
     parse!(int[char[]])();
}


-- 

http://d.puremagic.com/issues/show_bug.cgi?id=1597





------- Comment #1 from aarti@interia.pl  2007-10-19 17:32 -------
Also syntax of matching for normal arrays is cryptic. It would be better to
have following syntax for matching arrays:
void parse(T : E[])() {} which is much more clear (match types which are
collections of elements of type E). Similarly some cleanups could be done in
is() expression for types.

proposed syntax for associative arrays:
void parse(T : V[K])() {}

Related proposal from Bill Baxter: http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D.learn&article_id=9858


-- 

http://d.puremagic.com/issues/show_bug.cgi?id=1597





------- Comment #2 from andrei@metalanguage.com  2007-10-19 17:35 -------
While acknowledging this as a bug in the language, below is a fix for the time being:

import std.stdio;

void parse(T, U = void, V = void)() {
    writeln("Wuddever");
}

void parse(T : U[V], U, V)() {
    writeln("Hash");
}

void main() {
    parse!(int[char[]])();
    parse!(int[])();
    parse!(int)();
}

The second suggestion:

void parse(T : E[])() {}

won't work because it's unclear whether E is a newly-introduced symbol ("must
be inferred") or a previously-defined symbol ("must be E that I defined in this
module").


-- 

> The second suggestion:
> 
> void parse(T : E[])() {}
> 
> won't work because it's unclear whether E is a newly-introduced symbol
> ("must be inferred") or a previously-defined symbol ("must be E that I
> defined in this module").

Probably your are right :-) That was more pointing problem, that proposing real solution. Maybe some kind of suggestion.

But in other hand probably you will admit that current solution:
void parse(T : T[])

is even worse?

Inside function you get something completely different than you put when instantiating template. Inside function T means element of array, while it is instantiated as T[].

PS. It seems that best way to talk with Andrei is to submit bug :D

http://d.puremagic.com/issues/show_bug.cgi?id=1597





------- Comment #3 from wbaxter@gmail.com  2007-10-19 17:52 -------
(In reply to comment #2)
> won't work because it's unclear whether E is a newly-introduced symbol ("must
> be inferred") or a previously-defined symbol ("must be E that I defined in this
> module").

What's wrong with the C++ way of specifying specializations?
Just
   void parse(T[])() {}


-- 

http://d.puremagic.com/issues/show_bug.cgi?id=1597





------- Comment #4 from andrei@metalanguage.com  2007-10-19 18:04 -------
(In reply to comment #3)
> (In reply to comment #2)
> > won't work because it's unclear whether E is a newly-introduced symbol ("must
> > be inferred") or a previously-defined symbol ("must be E that I defined in this
> > module").
> 
> What's wrong with the C++ way of specifying specializations?
> Just
>    void parse(T[])() {}
> 

It has the same problem. Consider:

// wanna specialize on hashes, and also pattern match T and U! Cool!
void parse(T[U])() {}

Now if the same module adds or imports a type called U, a bad time is being had.


-- 

http://d.puremagic.com/issues/show_bug.cgi?id=1597





------- Comment #5 from aarti@interia.pl  2007-10-19 18:19 -------
(In reply to comment #2)
But in other hand probably you will admit that current solution:
void parse(T : T[])

is even worse?

Inside function you get something completely different than you put when instantiating template. Inside function T means element of array, while it is instantiated as T[].

So maybe:
void parse(T : auto E[]) {} and
void parse(T : auto V[K]) {}
to say that these symbols are inferred?


-- 

http://d.puremagic.com/issues/show_bug.cgi?id=1597





------- Comment #6 from andrei@metalanguage.com  2007-10-19 18:35 -------
(In reply to comment #5)
> (In reply to comment #2)
> But in other hand probably you will admit that current solution:
> void parse(T : T[])
> 
> is even worse?
> 
> Inside function you get something completely different than you put when instantiating template. Inside function T means element of array, while it is instantiated as T[].

That's very ugly but Walter cannot be convinced to give it up.

> So maybe:
> void parse(T : auto E[]) {} and
> void parse(T : auto V[K]) {}
> to say that these symbols are inferred?

This idea has been iterated a number of times. In the end, there was admission that the current syntax of appending the symbols to the list is as good as any other.


--