Re: Allowing arbitrary types for a function's argument and return type

[Adam D. Ruppe via Digitalmars-d-learn]

On Thursday, 22 October 2015 at 13:53:33 UTC, pineapple wrote:
import std.concurrency;
Generator!int sequence(int i){
    return new Generator!int({
        yield(i);
        while(i > 1){
            yield(i = (i % 2) ? (i * 3 + 1) : (i >> 1));
        }
    });
}
Which can be used like so:

import std.stdio;
void main(){
    foreach(i; sequence(11)){
        writeln(i);
    }
}

And now I'd like to make one more improvement, but this I 
haven't been able to figure out. What if I wanted the argument 
and output types to be longs instead of ints?

D's templates are easy (you actually used one in there, the 
Generator is one!)

Try this:

import std.concurrency;
Generator!T sequence(T)(T i){
    return new Generator!T({
        yield(i);
        while(i > 1){
            yield(i = (i % 2) ? (i * 3 + 1) : (i >> 1));
        }
    });
}


The first set of args, `(T)`, are the template arguments. You can 
then use hat anywhere in teh function as a type placeholder.


Now, when you call it, it can automatically deduce the types:

     foreach(i; sequence(11)){ // still works, uses int
     foreach(i; sequence(11L)){ // also works, uses long now

Or you can tell your own args explicitly:

     foreach(i; sequence!long(11)){ // uses long



The pattern is name!(template, args, ...)(regular, args...)

The ! introduces template arguments. If there is just one simple 
argument - one consisting of a single word - you can leaves the 
parenthesis out.