How to export a deduced template type to the enclosing scope?

[Ali Çehreli via Digitalmars-d-learn]

I think similar questions were asked by others in different contexts before.

I played with core.thread.Fibre a little bit. As others have done a 
number of times before, I tried to make the following syntax possible 
inside fiber code:

     yield(42);

I wonder whether there is a clever trick to pull out a deduced type from 
a template. I don't think it is possible, because there may be many 
instantiations of the template and it would not be clear which one to 
pull out. (I don't think there is any way of getting all of the 
instantiations of a template because the compiler has only a partial 
view of the program at a time.)

However, what if there is exactly one instantiation allowed?

struct S(alias Func)
{
     /* This template mixin will instantiate the yield(T) template. */
     mixin Func!();

     void yield(T)(T)
     {
         /* As expected and demonstrated by the following pragma, in
          * this case T happens to be 'double'. Assuming that Func is
          * not allowed to call yield() with more than one type, can we
          * pull the actual type of T out into S's scope? */

         alias YieldedT = T;
         pragma(msg, YieldedT);    /* Prints 'double'. */
     }

     /* QUESTION: Can we know the type for the single instantiation of
      *           yield(T) here? */

     YieldedT data;    /* What is YieldedT? */
}

mixin template MyFunc()
{
     void foo()
     {
         double d;
         yield(d);    /* <-- The single instantiation */
     }
}

void main()
{
     auto s = S!MyFunc();
     s.foo();
}

So near and yet so far... :)

Ali