Giant template - changing types everywhere

[Christian Köstlin]

On 14.07.23 16:15, Steven Schveighoffer wrote:
> On 7/14/23 1:51 AM, Cecil Ward wrote:
>> On Friday, 14 July 2023 at 05:09:58 UTC, Cecil Ward wrote:
>>> On Friday, 14 July 2023 at 05:05:27 UTC, Cecil Ward wrote:
>>>> On Friday, 14 July 2023 at 05:03:31 UTC, Cecil Ward wrote:
>>>>>
>>>>> The way I can see it going is a giant template encompassing pretty 
>>>>> much the whole file. Does that mean that the caller who calls my 
>>>>> one public function does so by passing the type dchar or wchar ? 
>>>>> And then we generate the strings from that. It might be rather more 
>>>>> natural for the caller to pass one of the string types into the 
>>>>> template. That’s where I get rather more confused, say caller calls
>>>>>
>>>>> Transform(dstring)(dstring str)
>>>>>
>>>>> or can they just do Transform( "str"d ) and it would work out that 
>>>>> the type is immutable dchar[] ?
>>>>
>>>> Perhaps I should just make up a small example file with two 
>>>> functions in it to see if I can get the syntax right?
>>>
>>> If I wrap the whole thing with a template declaration of the xchar 
>>> type, then can I get away with no changes to the individual function 
>>> definitions?
>>
>> I tried it, wrapped the whole thing in a template definition and it 
>> compiled, but then my test file which calls Transform( someDString ) 
>> failed to compile with errors saying it couldn’t find the definition 
>> of Transform in the other module, which is or was public. It’s as if 
>> it is no longer public because it’s now inside the template.
> 
> So templates don't automatically instantiate, you have to specify them. 
> And then if your function is inside the template, to access it, you will 
> need to do:
> 
> ```d
> GiantTemplate!dstring.Transform(str);
> ```
> 
> But this is not a usual way of creating API. Instead, you should 
> template individual functions on the string type.
> 
> Depending on what you are doing, you can use:
> 
> ```d
> T Transform(T)(T val)
> T[] Transform(T)(T[] val)
> ```
> 
> The first will cover cases where you have custom string types that 
> aren't arrays, the second will just capture the array type, and ensures 
> that the parameter/return is an array.
> 
> When you make template functions like this, a feature of D called 
> Implicit Function Template Instantiation (IFTI) will automatically 
> instantiate the template for you, so you don't have to specify the 
> template parameters.
> 
> You just call `Transform(str)` and it works. With the wrapping template 
> solution, this is not available -- you must explicitly instantiate the 
> wrapper.
> 
> If you are having problems, it is nearly impossible to diagnose without 
> some actual code to look at.
> 
> -Steve
Would Eponymous Templates 
(https://dlang.org/spec/template.html#implicit_template_properties) work 
with the wrapping template?

Kind regards,
Christian