Template specialisation, "Generic type locking", offline stdlib docs and case-based template question

Adam D. Ruppe destructionator at gmail.com
Fri Dec 1 04:34:53 UTC 2017


On Friday, 1 December 2017 at 03:39:12 UTC, helxi wrote:
> 1. Template specialisation.
> Why is this useful?:
> T getResponse(T = int)(string question); And how does it differ 
> from
> int getResponse(string question); ?


Because you can change the T at the call site. Let me give you a 
real world example from my cgi.d

docs:
http://dpldocs.info/experimental-docs/arsd.cgi.Cgi.request.html

source:
https://github.com/adamdruppe/arsd/blob/master/cgi.d#L2057


In the doc example, you'll see:

int a = cgi.request("number", 10);

You can also do:

string name = cgi.request("name");

or something kinda crazy like:

float number = cgi.request!float("brightness");



In the first case, it uses the passed param - 10 - to infer the 
type of T you want returned. It sees 10 is an int, so it tries to 
convert the value from the URL to an int and return it.

The second case uses the default parameter, described in the link 
you gave. The default here is (T = string), so if you don't 
specify anything else, it simply returns a string.

The third case shows explicit passing of a new type, instead of 
using the default T = string, we get T = float, so the function 
converts the value from URL to float and returns that.

All three of these uses are supported by the code.

> 2. "Generic locking".
> Is it possible to specialise templates for a certain group of 
> types? For example
> auto fn(T)(T arg)
> auto fn(T : int, double, float, ulong)(T arg); //shares same 
> behaviour
> auto fn(T : char, string, dchar, wchar, dstring, wstring)(T 
> arg); // shares same behavior

Yeah, that is possible.


> class Stack(T)
> {
> private:
>     T[] data;
> public:
>     this(T)(T[] data){ /*..*/}
>     this(T)(){}
>
>    //...
>
> }
>
> void main()
> {
>     auto s = new Stack!int;
> }
>
> Says:
>  Error: template app.Stack!int.Stack.__ctor cannot deduce 
> function from argument types !()(), candidates are:
> source/app.d(6,2):        app.Stack!int.Stack.__ctor(T)(T[] 
> data)
> source/app.d(9,2):        app.Stack!int.Stack.__ctor(T)()
>
> Why is Stack!int a ctor()() instead of a ctor(int)()?

You passed int to the Stack(T) template, but not to the this(T) 
template. There's two levels there, the outer argument and the 
inner argument.

It is the same as if you did a

void delegate(int) returns_a_function(int);

if you called

returns_a_function(0), it would still return the delegate. If you 
want to call both, you need another set of params to pass an 
argument to the returned function, too.




More information about the Digitalmars-d-learn mailing list