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

[John Colvin via Digitalmars-d-learn]

On Thursday, 22 October 2015 at 13:53:33 UTC, pineapple wrote:
I'm just starting to hammer D's very pleasant syntax into my 
head. After "Hello world", the first thing I do when learning 
any language is to write a simple program which generates and 
outputs the Collatz sequence for an arbitrary number. (I also 
like to golf it.) This is what I wrote in D:

import std.stdio;void main(){int i;readf(" 
%d",&i);while(i>1){writeln(i=i%2?i*3+1:i/2);}}

Any ways I could shorten it further?

Anyway, then I thought I should try something that was less of 
a mess, too, and wrote this:

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? Or some other, 
arbitrary discrete numeric type? Is there any template-like 
syntax I can use here instead of just copypasting for each 
numeric type I can think of? I've been spoiled by the likes of 
Python to be thinking in this duck-typing way.

Thanks!

Using ranges instead of threads or fibers, slightly 
over-engineered to show off features:

import std.traits : isIntegral;

auto collatzStep(T)(T i)
if(isIntegral!T)
{
    return (i % 2) ? (i * 3 + 1) : (i >> 1);
}

auto collatz(T)(T a)
if(isIntegral!T)
{
    import std.range : recurrence;
    import std.algorithm : until, OpenRight;
    return a.recurrence!((a, n) => collatzStep(a[n-1]))
            .until!(n => n == 1)(OpenRight.no);
}

unittest
{
    import std.algorithm : equal;
    import std.range : only;
    assert(collatz(6L).equal(only(6, 3, 10, 5, 16, 8, 4, 2, 1)));
}