Static strings in templates

[Sean Kelly]

Janice Caron wrote:
> I don't know if this is a bug or not. Someone please help me out.
> Here's the deal. Suppose I declare:
> 
>     int foo(T)(T s, T t)
> 
> with the expectation that the template will be passed a couple of
> strings, wstrings or dstring. All works fine if I do
> 
>     string s;
>     string t;
>     int n = foo(s,t);
> 
> However, the template can't be instantiated with
> 
>     int n = foo("abcde","fg");
> 
> because the type of the first argument is invariant(char)[5u], and the
> type of the second argument is invariant(char)[2u], and the compiler
> can't figure out that both can (and should) be implicitly cast to
> invariant(char)[].

I think this should work:

     int foo(T)( T[] s, T[] t );

If you want it to accept types other than arrays, however, then things 
get a bit more complicated:

     int foo(T,U)( T s, U t )
     {
         static if( isStaticArray!(T) || isStaticArray!(U) )
             return foo_!(ElemTypeOf!(T)[])( s, t );
         else
             return foo_!(T)( s, t );
     }

     int foo_(T)( T s, T t );

> It occurs to me that even with only a single parameter, passing string
> literals to templated string function will lead to a lot of template
> bloat, if the template always considers the argument type to be
> invariant(char)[N] (for some N), as opposed to simply
> invariant(char)[].
> 
> Is this a bug? Can anything be done about this? Is there a workaround?

It's not a bug, though it would be nice if there were some way to force 
parameters to dynamic arrays a bit easier.  Perhaps if the parameter 
were 'const', 'invariant', or 'in' it could be done automatically, since 
the length restriction is unnecessary in that case.


Sean