How to implement Canceleable spawn() from parent

[aberba via Digitalmars-d-learn]

Trying to implement a setInterval() that I can cancel using:
Tid tid = setInterval(2000, (){ writeln("hello");})

And then I can do:

stopInterval(tid);


With something like this:

stopInterval(Tid tid) {
    send(tid, "cancel");
}

import std.stdio : writeln;
import std.concurrency : receive, spawn, thisTid, Tid;

auto setInterval(long milliseconds, void delegate() callback)
{
    auto worker(long mls, void delegate() cb)
    {
        import core.thread.osthread : Thread;
        import std.datetime : seconds, msecs;

        writeln("Starting ", thisTid, "...");

        bool done = false;

        receive((string text) {
           writeln("Received string: ", text);
           done = true;
        });

        do
        {
            // or receive() comes here?

            Thread.sleep(mls.msecs);
            cb();
        }
        while (!done);
    }

    // I guess issue is with the callback
    Tid id = spawn(&worker, milliseconds, &callback);

    return id;
}



Getting error:

Error: template std.concurrency.spawn cannot deduce function from 
argument types !()(void delegate(Tid id) @system, Tid), 
candidates are:
/usr/include/dmd/phobos/std/concurrency.d(460,5):        spawn(F, 
T...)(F fn, T args)
  with F = void delegate(Tid) @system,
       T = (Tid)
  must satisfy the following constraint:
       isSpawnable!(F, T)


Am I even using the right tool here?